diff --git a/Assets/Editor/BFBuildProjectTools/Utils/BuildAndroidUtils.cs b/Assets/Editor/BFBuildProjectTools/Utils/BuildAndroidUtils.cs index a6962a65d..690c2ffca 100644 --- a/Assets/Editor/BFBuildProjectTools/Utils/BuildAndroidUtils.cs +++ b/Assets/Editor/BFBuildProjectTools/Utils/BuildAndroidUtils.cs @@ -144,18 +144,9 @@ namespace BFEditor.Build } PlayerSettings.SetScriptingDefineSymbolsForGroup(BuildTargetGroup.Android, symbols); - Debug.Log("[bfinfo]设置defineSymbols: " + symbols); + Debug.Log("[bfinfo]设置defineSymbols: " + symbols); - // 商品名称 - // 应用名 - if (buildInfo.IsPublish()) - { - PlayerSettings.productName = "Knights Combo"; - } - else - { - PlayerSettings.productName = "b6-dev"; - } + PlayerSettings.productName = "C1"; EditorUserBuildSettings.development = false; EditorUserBuildSettings.androidBuildType = AndroidBuildType.Release; diff --git a/Assets/Scripts/Const/BFPlatform.Gate.cs b/Assets/Scripts/Const/BFPlatform.Gate.cs index c7f92f90f..6ce4ff595 100644 --- a/Assets/Scripts/Const/BFPlatform.Gate.cs +++ b/Assets/Scripts/Const/BFPlatform.Gate.cs @@ -64,9 +64,9 @@ namespace BF public partial class BFPlatform { - const String LoginCenterURLDev = "http://game.juzugame.com:3000"; - const String LoginCenterURL = "https://entrance.bigfoot-studio.link"; - const String LoginCenterURLRU = "https://entrance-ru.bigfoot-studio.link"; + const String LoginCenterURLDev = "https://entrance.wdd817.link"; + const String LoginCenterURL = "https://entrance.wdd817.link"; + const String LoginCenterURLRU = "https://entrance.wdd817.link"; //combine url解析的数据 static ClusterType clusterType; diff --git a/Assets/XLua/Gen/AFInAppEventParameterNameWrap.cs b/Assets/XLua/Gen/AFInAppEventParameterNameWrap.cs new file mode 100644 index 000000000..f871c7a6d --- /dev/null +++ b/Assets/XLua/Gen/AFInAppEventParameterNameWrap.cs @@ -0,0 +1,161 @@ +#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 AFInAppEventParameterNameWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(AFInAppEventParameterName); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 78, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LEVEL", AFInAppEventParameterName.LEVEL); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SCORE", AFInAppEventParameterName.SCORE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SUCCESS", AFInAppEventParameterName.SUCCESS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PRICE", AFInAppEventParameterName.PRICE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CONTENT_TYPE", AFInAppEventParameterName.CONTENT_TYPE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CONTENT_ID", AFInAppEventParameterName.CONTENT_ID); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CONTENT_LIST", AFInAppEventParameterName.CONTENT_LIST); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CURRENCY", AFInAppEventParameterName.CURRENCY); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "QUANTITY", AFInAppEventParameterName.QUANTITY); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "REGSITRATION_METHOD", AFInAppEventParameterName.REGSITRATION_METHOD); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PAYMENT_INFO_AVAILIBLE", AFInAppEventParameterName.PAYMENT_INFO_AVAILIBLE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MAX_RATING_VALUE", AFInAppEventParameterName.MAX_RATING_VALUE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RATING_VALUE", AFInAppEventParameterName.RATING_VALUE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SEARCH_STRING", AFInAppEventParameterName.SEARCH_STRING); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DATE_A", AFInAppEventParameterName.DATE_A); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DATE_B", AFInAppEventParameterName.DATE_B); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DESTINATION_A", AFInAppEventParameterName.DESTINATION_A); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DESTINATION_B", AFInAppEventParameterName.DESTINATION_B); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DESCRIPTION", AFInAppEventParameterName.DESCRIPTION); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CLASS", AFInAppEventParameterName.CLASS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EVENT_START", AFInAppEventParameterName.EVENT_START); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EVENT_END", AFInAppEventParameterName.EVENT_END); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LATITUDE", AFInAppEventParameterName.LATITUDE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LONGTITUDE", AFInAppEventParameterName.LONGTITUDE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CUSTOMER_USER_ID", AFInAppEventParameterName.CUSTOMER_USER_ID); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VALIDATED", AFInAppEventParameterName.VALIDATED); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "REVENUE", AFInAppEventParameterName.REVENUE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PROJECTED_REVENUE", AFInAppEventParameterName.PROJECTED_REVENUE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RECEIPT_ID", AFInAppEventParameterName.RECEIPT_ID); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TUTORIAL_ID", AFInAppEventParameterName.TUTORIAL_ID); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ACHIEVEMENT_ID", AFInAppEventParameterName.ACHIEVEMENT_ID); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VIRTUAL_CURRENCY_NAME", AFInAppEventParameterName.VIRTUAL_CURRENCY_NAME); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DEEP_LINK", AFInAppEventParameterName.DEEP_LINK); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OLD_VERSION", AFInAppEventParameterName.OLD_VERSION); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NEW_VERSION", AFInAppEventParameterName.NEW_VERSION); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "REVIEW_TEXT", AFInAppEventParameterName.REVIEW_TEXT); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "COUPON_CODE", AFInAppEventParameterName.COUPON_CODE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PARAM_1", AFInAppEventParameterName.PARAM_1); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PARAM_2", AFInAppEventParameterName.PARAM_2); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PARAM_3", AFInAppEventParameterName.PARAM_3); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PARAM_4", AFInAppEventParameterName.PARAM_4); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PARAM_5", AFInAppEventParameterName.PARAM_5); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PARAM_6", AFInAppEventParameterName.PARAM_6); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PARAM_7", AFInAppEventParameterName.PARAM_7); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PARAM_8", AFInAppEventParameterName.PARAM_8); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PARAM_9", AFInAppEventParameterName.PARAM_9); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PARAM_10", AFInAppEventParameterName.PARAM_10); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ORDER_ID", AFInAppEventParameterName.ORDER_ID); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DEPARTING_DEPARTURE_DATE", AFInAppEventParameterName.DEPARTING_DEPARTURE_DATE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RETURNING_DEPARTURE_DATE", AFInAppEventParameterName.RETURNING_DEPARTURE_DATE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DESTINATION_LIST", AFInAppEventParameterName.DESTINATION_LIST); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CITY", AFInAppEventParameterName.CITY); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "REGION", AFInAppEventParameterName.REGION); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "COUNTRY", AFInAppEventParameterName.COUNTRY); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DEPARTING_ARRIVAL_DATE", AFInAppEventParameterName.DEPARTING_ARRIVAL_DATE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RETURNING_ARRIVAL_DATE", AFInAppEventParameterName.RETURNING_ARRIVAL_DATE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SUGGESTED_DESTINATIONS", AFInAppEventParameterName.SUGGESTED_DESTINATIONS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TRAVEL_START", AFInAppEventParameterName.TRAVEL_START); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TRAVEL_END", AFInAppEventParameterName.TRAVEL_END); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NUM_ADULTS", AFInAppEventParameterName.NUM_ADULTS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NUM_CHILDREN", AFInAppEventParameterName.NUM_CHILDREN); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NUM_INFANTS", AFInAppEventParameterName.NUM_INFANTS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SUGGESTED_HOTELS", AFInAppEventParameterName.SUGGESTED_HOTELS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "USER_SCORE", AFInAppEventParameterName.USER_SCORE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HOTEL_SCORE", AFInAppEventParameterName.HOTEL_SCORE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PURCHASE_CURRENCY", AFInAppEventParameterName.PURCHASE_CURRENCY); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PREFERRED_STAR_RATINGS", AFInAppEventParameterName.PREFERRED_STAR_RATINGS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PREFERRED_PRICE_RANGE", AFInAppEventParameterName.PREFERRED_PRICE_RANGE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PREFERRED_NEIGHBORHOODS", AFInAppEventParameterName.PREFERRED_NEIGHBORHOODS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PREFERRED_NUM_STOPS", AFInAppEventParameterName.PREFERRED_NUM_STOPS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AF_CHANNEL", AFInAppEventParameterName.AF_CHANNEL); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CONTENT", AFInAppEventParameterName.CONTENT); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AD_REVENUE_AD_TYPE", AFInAppEventParameterName.AD_REVENUE_AD_TYPE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AD_REVENUE_NETWORK_NAME", AFInAppEventParameterName.AD_REVENUE_NETWORK_NAME); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AD_REVENUE_PLACEMENT_ID", AFInAppEventParameterName.AD_REVENUE_PLACEMENT_ID); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AD_REVENUE_AD_SIZE", AFInAppEventParameterName.AD_REVENUE_AD_SIZE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AD_REVENUE_MEDIATED_NETWORK_NAME", AFInAppEventParameterName.AD_REVENUE_MEDIATED_NETWORK_NAME); + + + + + 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 AFInAppEventParameterName(); + 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 AFInAppEventParameterName constructor!"); + + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/AFInAppEventTypeWrap.cs b/Assets/XLua/Gen/AFInAppEventTypeWrap.cs new file mode 100644 index 000000000..ce81658a9 --- /dev/null +++ b/Assets/XLua/Gen/AFInAppEventTypeWrap.cs @@ -0,0 +1,113 @@ +#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 AFInAppEventTypeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(AFInAppEventType); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 30, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LEVEL_ACHIEVED", AFInAppEventType.LEVEL_ACHIEVED); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ADD_PAYMENT_INFO", AFInAppEventType.ADD_PAYMENT_INFO); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ADD_TO_CART", AFInAppEventType.ADD_TO_CART); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ADD_TO_WISH_LIST", AFInAppEventType.ADD_TO_WISH_LIST); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "COMPLETE_REGISTRATION", AFInAppEventType.COMPLETE_REGISTRATION); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TUTORIAL_COMPLETION", AFInAppEventType.TUTORIAL_COMPLETION); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "INITIATED_CHECKOUT", AFInAppEventType.INITIATED_CHECKOUT); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PURCHASE", AFInAppEventType.PURCHASE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RATE", AFInAppEventType.RATE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SEARCH", AFInAppEventType.SEARCH); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SPENT_CREDIT", AFInAppEventType.SPENT_CREDIT); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ACHIEVEMENT_UNLOCKED", AFInAppEventType.ACHIEVEMENT_UNLOCKED); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CONTENT_VIEW", AFInAppEventType.CONTENT_VIEW); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TRAVEL_BOOKING", AFInAppEventType.TRAVEL_BOOKING); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SHARE", AFInAppEventType.SHARE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "INVITE", AFInAppEventType.INVITE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LOGIN", AFInAppEventType.LOGIN); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RE_ENGAGE", AFInAppEventType.RE_ENGAGE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UPDATE", AFInAppEventType.UPDATE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OPENED_FROM_PUSH_NOTIFICATION", AFInAppEventType.OPENED_FROM_PUSH_NOTIFICATION); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LOCATION_CHANGED", AFInAppEventType.LOCATION_CHANGED); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LOCATION_COORDINATES", AFInAppEventType.LOCATION_COORDINATES); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ORDER_ID", AFInAppEventType.ORDER_ID); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CUSTOMER_SEGMENT", AFInAppEventType.CUSTOMER_SEGMENT); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LIST_VIEW", AFInAppEventType.LIST_VIEW); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SUBSCRIBE", AFInAppEventType.SUBSCRIBE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "START_TRIAL", AFInAppEventType.START_TRIAL); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AD_CLICK", AFInAppEventType.AD_CLICK); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AD_VIEW", AFInAppEventType.AD_VIEW); + + + + + 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 AFInAppEventType(); + 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 AFInAppEventType constructor!"); + + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/AdManagerWrap.cs b/Assets/XLua/Gen/AdManagerWrap.cs new file mode 100644 index 000000000..a4fbe715a --- /dev/null +++ b/Assets/XLua/Gen/AdManagerWrap.cs @@ -0,0 +1,582 @@ +#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 AdManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(AdManager); + Utils.BeginObjectRegister(type, L, translator, 0, 15, 1, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAdRevenuePaidEventCallback", _m_SetAdRevenuePaidEventCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsRewardedAdReady", _m_IsRewardedAdReady); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ShowRewardedAd", _m_ShowRewardedAd); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsInterstitialReady", _m_IsInterstitialReady); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ShowInterstitial", _m_ShowInterstitial); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ShowBanner", _m_ShowBanner); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HideBanner", _m_HideBanner); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DestroyBanner", _m_DestroyBanner); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsPrivacyOptionsRequired", _m_IsPrivacyOptionsRequired); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ShowPrivacyOptionsForm", _m_ShowPrivacyOptionsForm); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CheckCanRequestAds", _m_CheckCanRequestAds); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InitializeBannerAds", _m_InitializeBannerAds); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InitializeInterstitialAds", _m_InitializeInterstitialAds); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InitializeRewardedAds", _m_InitializeRewardedAds); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaAdRevenuePaidEventCallback", _g_get_luaAdRevenuePaidEventCallback); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaAdRevenuePaidEventCallback", _s_set_luaAdRevenuePaidEventCallback); + + + 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 AdManager(); + 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 AdManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + AdManager gen_to_be_invoked = (AdManager)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _init = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.Init( _init ); + + + + return 0; + } + if(gen_param_count == 1) + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to AdManager.Init!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAdRevenuePaidEventCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + AdManager gen_to_be_invoked = (AdManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetAdRevenuePaidEventCallback( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsRewardedAdReady(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + AdManager gen_to_be_invoked = (AdManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsRewardedAdReady( ); + 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_ShowRewardedAd(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + AdManager gen_to_be_invoked = (AdManager)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Action _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.ShowRewardedAd( _callback ); + + + + return 0; + } + if(gen_param_count == 1) + { + + gen_to_be_invoked.ShowRewardedAd( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to AdManager.ShowRewardedAd!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsInterstitialReady(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + AdManager gen_to_be_invoked = (AdManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsInterstitialReady( ); + 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_ShowInterstitial(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + AdManager gen_to_be_invoked = (AdManager)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Action _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.ShowInterstitial( _callback ); + + + + return 0; + } + if(gen_param_count == 1) + { + + gen_to_be_invoked.ShowInterstitial( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to AdManager.ShowInterstitial!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ShowBanner(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + AdManager gen_to_be_invoked = (AdManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ShowBanner( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HideBanner(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + AdManager gen_to_be_invoked = (AdManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.HideBanner( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DestroyBanner(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + AdManager gen_to_be_invoked = (AdManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.DestroyBanner( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsPrivacyOptionsRequired(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + AdManager gen_to_be_invoked = (AdManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsPrivacyOptionsRequired( ); + 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_ShowPrivacyOptionsForm(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + AdManager gen_to_be_invoked = (AdManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ShowPrivacyOptionsForm( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CheckCanRequestAds(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + AdManager gen_to_be_invoked = (AdManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.CheckCanRequestAds( ); + 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_InitializeBannerAds(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + AdManager gen_to_be_invoked = (AdManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.InitializeBannerAds( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_InitializeInterstitialAds(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + AdManager gen_to_be_invoked = (AdManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.InitializeInterstitialAds( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_InitializeRewardedAds(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + AdManager gen_to_be_invoked = (AdManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.InitializeRewardedAds( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaAdRevenuePaidEventCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + AdManager gen_to_be_invoked = (AdManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaAdRevenuePaidEventCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_luaAdRevenuePaidEventCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + AdManager gen_to_be_invoked = (AdManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaAdRevenuePaidEventCallback = translator.GetDelegate>(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_AbsPostEffectWrap.cs b/Assets/XLua/Gen/BF_AbsPostEffectWrap.cs new file mode 100644 index 000000000..cc7b098c6 --- /dev/null +++ b/Assets/XLua/Gen/BF_AbsPostEffectWrap.cs @@ -0,0 +1,128 @@ +#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 BFAbsPostEffectWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.AbsPostEffect); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 1, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRenderImage", _m_OnRenderImage); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "active", _g_get_active); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "active", _s_set_active); + + + 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, "BF.AbsPostEffect does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnRenderImage(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AbsPostEffect gen_to_be_invoked = (BF.AbsPostEffect)translator.FastGetCSObj(L, 1); + + + + { + BF.PostEffectContext _context = (BF.PostEffectContext)translator.GetObject(L, 2, typeof(BF.PostEffectContext)); + + var gen_ret = gen_to_be_invoked.OnRenderImage( _context ); + 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_active(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AbsPostEffect gen_to_be_invoked = (BF.AbsPostEffect)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.active); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_active(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AbsPostEffect gen_to_be_invoked = (BF.AbsPostEffect)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.active = LuaAPI.lua_toboolean(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_AesEncryptWrap.cs b/Assets/XLua/Gen/BF_AesEncryptWrap.cs new file mode 100644 index 000000000..1224d349c --- /dev/null +++ b/Assets/XLua/Gen/BF_AesEncryptWrap.cs @@ -0,0 +1,162 @@ +#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 BFAesEncryptWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.AesEncrypt); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 4, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Encrypt", _m_Encrypt_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Decrypt", _m_Decrypt_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Clear", _m_Clear_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 BF.AesEncrypt(); + 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.AesEncrypt constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Encrypt_xlua_st_(RealStatePtr L) + { + try { + + + + + { + byte[] _buffer = LuaAPI.lua_tobytes(L, 1); + string _key = LuaAPI.lua_tostring(L, 2); + + var gen_ret = BF.AesEncrypt.Encrypt( _buffer, _key ); + 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 _m_Decrypt_xlua_st_(RealStatePtr L) + { + try { + + + + + { + byte[] _buffer = LuaAPI.lua_tobytes(L, 1); + string _key = LuaAPI.lua_tostring(L, 2); + + var gen_ret = BF.AesEncrypt.Decrypt( _buffer, _key ); + 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 _m_Clear_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + BF.AesEncrypt.Clear( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_AssetBundleConfigCollectionWrap.cs b/Assets/XLua/Gen/BF_AssetBundleConfigCollectionWrap.cs new file mode 100644 index 000000000..85b167636 --- /dev/null +++ b/Assets/XLua/Gen/BF_AssetBundleConfigCollectionWrap.cs @@ -0,0 +1,529 @@ +#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 BFAssetBundleConfigCollectionWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.AssetBundleConfigCollection); + Utils.BeginObjectRegister(type, L, translator, 0, 8, 4, 4); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetConfigByBundlePath", _m_GetConfigByBundlePath); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetConfigByMainBundlePath", _m_GetConfigByMainBundlePath); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetConfigByAssetPath", _m_GetConfigByAssetPath); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetConfigByMd5", _m_GetConfigByMd5); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToJson", _m_ToJson); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddAssetBundleConfig", _m_AddAssetBundleConfig); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddLangAssetBundleConfig", _m_AddLangAssetBundleConfig); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetLanguageConfigByName", _m_GetLanguageConfigByName); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "version", _g_get_version); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mainConfigs", _g_get_mainConfigs); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "languageConfigs", _g_get_languageConfigs); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "allConfigs", _g_get_allConfigs); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "version", _s_set_version); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "mainConfigs", _s_set_mainConfigs); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "languageConfigs", _s_set_languageConfigs); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "allConfigs", _s_set_allConfigs); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 4, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Create", _m_Create_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Compress", _m_Compress_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Decompress", _m_Decompress_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 BF.AssetBundleConfigCollection(); + 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.AssetBundleConfigCollection constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetConfigByBundlePath(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleConfigCollection gen_to_be_invoked = (BF.AssetBundleConfigCollection)translator.FastGetCSObj(L, 1); + + + + { + string _bundlePath = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetConfigByBundlePath( _bundlePath ); + 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_GetConfigByMainBundlePath(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleConfigCollection gen_to_be_invoked = (BF.AssetBundleConfigCollection)translator.FastGetCSObj(L, 1); + + + + { + string _bundlePath = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetConfigByMainBundlePath( _bundlePath ); + 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_GetConfigByAssetPath(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleConfigCollection gen_to_be_invoked = (BF.AssetBundleConfigCollection)translator.FastGetCSObj(L, 1); + + + + { + string _assetPath = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetConfigByAssetPath( _assetPath ); + 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_GetConfigByMd5(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleConfigCollection gen_to_be_invoked = (BF.AssetBundleConfigCollection)translator.FastGetCSObj(L, 1); + + + + { + string _md5 = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetConfigByMd5( _md5 ); + 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_ToJson(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleConfigCollection gen_to_be_invoked = (BF.AssetBundleConfigCollection)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.ToJson( ); + 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 _m_AddAssetBundleConfig(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleConfigCollection gen_to_be_invoked = (BF.AssetBundleConfigCollection)translator.FastGetCSObj(L, 1); + + + + { + BF.AssetBundleConfig _cfg = (BF.AssetBundleConfig)translator.GetObject(L, 2, typeof(BF.AssetBundleConfig)); + + gen_to_be_invoked.AddAssetBundleConfig( _cfg ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddLangAssetBundleConfig(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleConfigCollection gen_to_be_invoked = (BF.AssetBundleConfigCollection)translator.FastGetCSObj(L, 1); + + + + { + string _languageName = LuaAPI.lua_tostring(L, 2); + BF.AssetBundleConfig _cfg = (BF.AssetBundleConfig)translator.GetObject(L, 3, typeof(BF.AssetBundleConfig)); + + gen_to_be_invoked.AddLangAssetBundleConfig( _languageName, _cfg ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetLanguageConfigByName(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleConfigCollection gen_to_be_invoked = (BF.AssetBundleConfigCollection)translator.FastGetCSObj(L, 1); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + BF.LanguageConfig _languageConfig; + + var gen_ret = gen_to_be_invoked.GetLanguageConfigByName( _name, out _languageConfig ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _languageConfig); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Create_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _json = LuaAPI.lua_tostring(L, 1); + + var gen_ret = BF.AssetBundleConfigCollection.Create( _json ); + 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_Compress_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _json = LuaAPI.lua_tostring(L, 1); + + var gen_ret = BF.AssetBundleConfigCollection.Compress( _json ); + 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 _m_Decompress_xlua_st_(RealStatePtr L) + { + try { + + + + + { + byte[] _bytes = LuaAPI.lua_tobytes(L, 1); + + var gen_ret = BF.AssetBundleConfigCollection.Decompress( _bytes ); + 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_version(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetBundleConfigCollection gen_to_be_invoked = (BF.AssetBundleConfigCollection)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.version); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mainConfigs(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetBundleConfigCollection gen_to_be_invoked = (BF.AssetBundleConfigCollection)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.mainConfigs); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_languageConfigs(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetBundleConfigCollection gen_to_be_invoked = (BF.AssetBundleConfigCollection)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.languageConfigs); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_allConfigs(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetBundleConfigCollection gen_to_be_invoked = (BF.AssetBundleConfigCollection)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.allConfigs); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_version(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetBundleConfigCollection gen_to_be_invoked = (BF.AssetBundleConfigCollection)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.version = 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_mainConfigs(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetBundleConfigCollection gen_to_be_invoked = (BF.AssetBundleConfigCollection)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.mainConfigs = (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; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_languageConfigs(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetBundleConfigCollection gen_to_be_invoked = (BF.AssetBundleConfigCollection)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.languageConfigs = (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; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_allConfigs(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetBundleConfigCollection gen_to_be_invoked = (BF.AssetBundleConfigCollection)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.allConfigs = (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/BF_AssetBundleConfigWrap.cs b/Assets/XLua/Gen/BF_AssetBundleConfigWrap.cs new file mode 100644 index 000000000..283026ee9 --- /dev/null +++ b/Assets/XLua/Gen/BF_AssetBundleConfigWrap.cs @@ -0,0 +1,299 @@ +#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 BFAssetBundleConfigWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.AssetBundleConfig); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 6, 6); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "assetBundlePath", _g_get_assetBundlePath); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "assetsPath", _g_get_assetsPath); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "md5", _g_get_md5); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "zipPath", _g_get_zipPath); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rawSize", _g_get_rawSize); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "location", _g_get_location); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "assetBundlePath", _s_set_assetBundlePath); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "assetsPath", _s_set_assetsPath); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "md5", _s_set_md5); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "zipPath", _s_set_zipPath); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "rawSize", _s_set_rawSize); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "location", _s_set_location); + + + 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.AssetBundleConfig(); + 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.AssetBundleConfig constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleConfig gen_to_be_invoked = (BF.AssetBundleConfig)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_assetBundlePath(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetBundleConfig gen_to_be_invoked = (BF.AssetBundleConfig)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.assetBundlePath); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_assetsPath(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetBundleConfig gen_to_be_invoked = (BF.AssetBundleConfig)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.assetsPath); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_md5(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetBundleConfig gen_to_be_invoked = (BF.AssetBundleConfig)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.md5); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_zipPath(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetBundleConfig gen_to_be_invoked = (BF.AssetBundleConfig)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.zipPath); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rawSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetBundleConfig gen_to_be_invoked = (BF.AssetBundleConfig)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushint64(L, gen_to_be_invoked.rawSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_location(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetBundleConfig gen_to_be_invoked = (BF.AssetBundleConfig)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.location); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_assetBundlePath(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetBundleConfig gen_to_be_invoked = (BF.AssetBundleConfig)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.assetBundlePath = 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_assetsPath(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetBundleConfig gen_to_be_invoked = (BF.AssetBundleConfig)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.assetsPath = (string[])translator.GetObject(L, 2, typeof(string[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_md5(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetBundleConfig gen_to_be_invoked = (BF.AssetBundleConfig)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.md5 = 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_zipPath(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetBundleConfig gen_to_be_invoked = (BF.AssetBundleConfig)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.zipPath = 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_rawSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetBundleConfig gen_to_be_invoked = (BF.AssetBundleConfig)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.rawSize = 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_location(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetBundleConfig gen_to_be_invoked = (BF.AssetBundleConfig)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.location = (byte)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_AssetBundleLoaderWrap.cs b/Assets/XLua/Gen/BF_AssetBundleLoaderWrap.cs new file mode 100644 index 000000000..c748dd798 --- /dev/null +++ b/Assets/XLua/Gen/BF_AssetBundleLoaderWrap.cs @@ -0,0 +1,614 @@ +#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 BFAssetBundleLoaderWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.AssetBundleLoader); + Utils.BeginObjectRegister(type, L, translator, 0, 15, 2, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadAssetAsync", _m_LoadAssetAsync); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadDependBundleAsync", _m_LoadDependBundleAsync); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadBundleAsync", _m_LoadBundleAsync); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadAssetSync", _m_LoadAssetSync); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadDependBundleSync", _m_LoadDependBundleSync); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Unload", _m_Unload); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnLoadBundle", _m_UnLoadBundle); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveCache", _m_RemoveCache); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Tick", _m_Tick); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnloadAllDelayAssets", _m_UnloadAllDelayAssets); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSceneLoadPath", _m_GetSceneLoadPath); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadSceneAsync", _m_LoadSceneAsync); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnloadScene", _m_UnloadScene); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ContainsAsset", _m_ContainsAsset); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Config", _g_get_Config); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Manifest", _g_get_Manifest); + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MAX_LOADING", BF.AssetBundleLoader.MAX_LOADING); + + + + + 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.AssetBundleLoader(); + 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.AssetBundleLoader constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadAssetAsync(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleLoader gen_to_be_invoked = (BF.AssetBundleLoader)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + BF.AssetObject _assetObject = (BF.AssetObject)translator.GetObject(L, 2, typeof(BF.AssetObject)); + + gen_to_be_invoked.LoadAssetAsync( _assetObject ); + + + + return 0; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)&& translator.Assignable>(L, 4)) + { + string _assetPath = LuaAPI.lua_tostring(L, 2); + System.Type _type = (System.Type)translator.GetObject(L, 3, typeof(System.Type)); + System.Action _complete = translator.GetDelegate>(L, 4); + + var gen_ret = gen_to_be_invoked.LoadAssetAsync( _assetPath, _type, _complete ); + 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.AssetBundleLoader.LoadAssetAsync!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadDependBundleAsync(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleLoader gen_to_be_invoked = (BF.AssetBundleLoader)translator.FastGetCSObj(L, 1); + + + + { + string _bundlePath = LuaAPI.lua_tostring(L, 2); + System.Action _complete = translator.GetDelegate>(L, 3); + + gen_to_be_invoked.LoadDependBundleAsync( _bundlePath, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadBundleAsync(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleLoader gen_to_be_invoked = (BF.AssetBundleLoader)translator.FastGetCSObj(L, 1); + + + + { + string _bundlePath = LuaAPI.lua_tostring(L, 2); + System.Action _complete = translator.GetDelegate>(L, 3); + + gen_to_be_invoked.LoadBundleAsync( _bundlePath, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadAssetSync(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleLoader gen_to_be_invoked = (BF.AssetBundleLoader)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + BF.AssetObject _assetObject = (BF.AssetObject)translator.GetObject(L, 2, typeof(BF.AssetObject)); + + gen_to_be_invoked.LoadAssetSync( _assetObject ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _assetPath = LuaAPI.lua_tostring(L, 2); + System.Type _type = (System.Type)translator.GetObject(L, 3, typeof(System.Type)); + + var gen_ret = gen_to_be_invoked.LoadAssetSync( _assetPath, _type ); + 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.AssetBundleLoader.LoadAssetSync!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadDependBundleSync(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleLoader gen_to_be_invoked = (BF.AssetBundleLoader)translator.FastGetCSObj(L, 1); + + + + { + string _bundlePath = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.LoadDependBundleSync( _bundlePath ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Unload(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleLoader gen_to_be_invoked = (BF.AssetBundleLoader)translator.FastGetCSObj(L, 1); + + + + { + BF.AssetObject _asset = (BF.AssetObject)translator.GetObject(L, 2, typeof(BF.AssetObject)); + bool _immediately = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.Unload( _asset, _immediately ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UnLoadBundle(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleLoader gen_to_be_invoked = (BF.AssetBundleLoader)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + BF.AssetObject _assetObject = (BF.AssetObject)translator.GetObject(L, 2, typeof(BF.AssetObject)); + bool _immediately = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.UnLoadBundle( _assetObject, _immediately ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + string _assetBundlePath = LuaAPI.lua_tostring(L, 2); + bool _immediately = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.UnLoadBundle( _assetBundlePath, _immediately ); + + + + return 0; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + string _assetBundlePath = LuaAPI.lua_tostring(L, 2); + bool _immediately = LuaAPI.lua_toboolean(L, 3); + System.Action _unloadCallback = translator.GetDelegate(L, 4); + + gen_to_be_invoked.UnLoadBundle( _assetBundlePath, _immediately, _unloadCallback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.AssetBundleLoader.UnLoadBundle!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveCache(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleLoader gen_to_be_invoked = (BF.AssetBundleLoader)translator.FastGetCSObj(L, 1); + + + + { + BF.AssetBundleObject _abo = (BF.AssetBundleObject)translator.GetObject(L, 2, typeof(BF.AssetBundleObject)); + + gen_to_be_invoked.RemoveCache( _abo ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Tick(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleLoader gen_to_be_invoked = (BF.AssetBundleLoader)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Tick( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UnloadAllDelayAssets(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleLoader gen_to_be_invoked = (BF.AssetBundleLoader)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.UnloadAllDelayAssets( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetSceneLoadPath(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleLoader gen_to_be_invoked = (BF.AssetBundleLoader)translator.FastGetCSObj(L, 1); + + + + { + string _assetBundlePath = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetSceneLoadPath( _assetBundlePath ); + 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 _m_LoadSceneAsync(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleLoader gen_to_be_invoked = (BF.AssetBundleLoader)translator.FastGetCSObj(L, 1); + + + + { + string _assetBundlePath = LuaAPI.lua_tostring(L, 2); + System.Action _complete = translator.GetDelegate>(L, 3); + + gen_to_be_invoked.LoadSceneAsync( _assetBundlePath, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UnloadScene(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleLoader gen_to_be_invoked = (BF.AssetBundleLoader)translator.FastGetCSObj(L, 1); + + + + { + string _assetBundlePath = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.UnloadScene( _assetBundlePath ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Clear(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleLoader gen_to_be_invoked = (BF.AssetBundleLoader)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Clear( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ContainsAsset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleLoader gen_to_be_invoked = (BF.AssetBundleLoader)translator.FastGetCSObj(L, 1); + + + + { + string _assetPath = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.ContainsAsset( _assetPath ); + 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 _g_get_Config(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetBundleLoader gen_to_be_invoked = (BF.AssetBundleLoader)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Config); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Manifest(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetBundleLoader gen_to_be_invoked = (BF.AssetBundleLoader)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Manifest); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_AssetBundleObjectWrap.cs b/Assets/XLua/Gen/BF_AssetBundleObjectWrap.cs new file mode 100644 index 000000000..cac1f9477 --- /dev/null +++ b/Assets/XLua/Gen/BF_AssetBundleObjectWrap.cs @@ -0,0 +1,374 @@ +#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 BFAssetBundleObjectWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.AssetBundleObject); + Utils.BeginObjectRegister(type, L, translator, 0, 7, 3, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadBundleAsync", _m_LoadBundleAsync); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "StartLoadAsync", _m_StartLoadAsync); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadSync", _m_LoadSync); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Tick", _m_Tick); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Complete", _m_Complete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddUnloadCallback", _m_AddUnloadCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Unload", _m_Unload); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AssetBundleConfig", _g_get_AssetBundleConfig); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Assetbundle", _g_get_Assetbundle); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Timeout", _g_get_Timeout); + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 1, 1); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "fullpathDict", _g_get_fullpathDict); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "fullpathDict", _s_set_fullpathDict); + + + 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 && translator.Assignable(L, 2) && translator.Assignable(L, 3)) + { + BF.AssetBundleConfig _config = (BF.AssetBundleConfig)translator.GetObject(L, 2, typeof(BF.AssetBundleConfig)); + BF.AssetBundleLoader _loader = (BF.AssetBundleLoader)translator.GetObject(L, 3, typeof(BF.AssetBundleLoader)); + + var gen_ret = new BF.AssetBundleObject(_config, _loader); + 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.AssetBundleObject constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadBundleAsync(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleObject gen_to_be_invoked = (BF.AssetBundleObject)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.LoadBundleAsync( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_StartLoadAsync(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleObject gen_to_be_invoked = (BF.AssetBundleObject)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.StartLoadAsync( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadSync(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleObject gen_to_be_invoked = (BF.AssetBundleObject)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _ignoreRefCount = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.LoadSync( _ignoreRefCount ); + + + + return 0; + } + if(gen_param_count == 1) + { + + gen_to_be_invoked.LoadSync( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.AssetBundleObject.LoadSync!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Tick(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleObject gen_to_be_invoked = (BF.AssetBundleObject)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Tick( ); + 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_Complete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleObject gen_to_be_invoked = (BF.AssetBundleObject)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.AssetBundle _ab = (UnityEngine.AssetBundle)translator.GetObject(L, 2, typeof(UnityEngine.AssetBundle)); + + gen_to_be_invoked.Complete( _ab ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddUnloadCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleObject gen_to_be_invoked = (BF.AssetBundleObject)translator.FastGetCSObj(L, 1); + + + + { + System.Action _unloadCallback = translator.GetDelegate(L, 2); + + gen_to_be_invoked.AddUnloadCallback( _unloadCallback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Unload(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetBundleObject gen_to_be_invoked = (BF.AssetBundleObject)translator.FastGetCSObj(L, 1); + + + + { + bool _immediately = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.Unload( _immediately ); + 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 _g_get_AssetBundleConfig(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetBundleObject gen_to_be_invoked = (BF.AssetBundleObject)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.AssetBundleConfig); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Assetbundle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetBundleObject gen_to_be_invoked = (BF.AssetBundleObject)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Assetbundle); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Timeout(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetBundleObject gen_to_be_invoked = (BF.AssetBundleObject)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.Timeout); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fullpathDict(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, BF.AssetBundleObject.fullpathDict); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_fullpathDict(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + BF.AssetBundleObject.fullpathDict = (System.Collections.Generic.Dictionary)translator.GetObject(L, 1, 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/BF_AssetLoaderWrap.cs b/Assets/XLua/Gen/BF_AssetLoaderWrap.cs new file mode 100644 index 000000000..71d26e35d --- /dev/null +++ b/Assets/XLua/Gen/BF_AssetLoaderWrap.cs @@ -0,0 +1,394 @@ +#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 BFAssetLoaderWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.AssetLoader); + Utils.BeginObjectRegister(type, L, translator, 0, 10, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadAssetAsync", _m_LoadAssetAsync); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadAssetSync", _m_LoadAssetSync); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Unload", _m_Unload); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSceneLoadPath", _m_GetSceneLoadPath); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadSceneAsync", _m_LoadSceneAsync); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnloadScene", _m_UnloadScene); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Tick", _m_Tick); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnloadAllDelayAssets", _m_UnloadAllDelayAssets); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ContainsAsset", _m_ContainsAsset); + + + + + + 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.AssetLoader(); + 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.AssetLoader constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadAssetAsync(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetLoader gen_to_be_invoked = (BF.AssetLoader)translator.FastGetCSObj(L, 1); + + + + { + string _assetPath = LuaAPI.lua_tostring(L, 2); + System.Type _type = (System.Type)translator.GetObject(L, 3, typeof(System.Type)); + System.Action _complete = translator.GetDelegate>(L, 4); + + var gen_ret = gen_to_be_invoked.LoadAssetAsync( _assetPath, _type, _complete ); + 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_LoadAssetSync(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetLoader gen_to_be_invoked = (BF.AssetLoader)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + BF.AssetObject _assetObject = (BF.AssetObject)translator.GetObject(L, 2, typeof(BF.AssetObject)); + + gen_to_be_invoked.LoadAssetSync( _assetObject ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _assetPath = LuaAPI.lua_tostring(L, 2); + System.Type _type = (System.Type)translator.GetObject(L, 3, typeof(System.Type)); + + var gen_ret = gen_to_be_invoked.LoadAssetSync( _assetPath, _type ); + 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.AssetLoader.LoadAssetSync!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Unload(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetLoader gen_to_be_invoked = (BF.AssetLoader)translator.FastGetCSObj(L, 1); + + + + { + BF.AssetObject _asset = (BF.AssetObject)translator.GetObject(L, 2, typeof(BF.AssetObject)); + bool _immediately = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.Unload( _asset, _immediately ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetSceneLoadPath(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetLoader gen_to_be_invoked = (BF.AssetLoader)translator.FastGetCSObj(L, 1); + + + + { + string _assetBundlePath = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetSceneLoadPath( _assetBundlePath ); + 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 _m_LoadSceneAsync(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetLoader gen_to_be_invoked = (BF.AssetLoader)translator.FastGetCSObj(L, 1); + + + + { + string _assetBundlePath = LuaAPI.lua_tostring(L, 2); + System.Action _complete = translator.GetDelegate>(L, 3); + + gen_to_be_invoked.LoadSceneAsync( _assetBundlePath, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UnloadScene(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetLoader gen_to_be_invoked = (BF.AssetLoader)translator.FastGetCSObj(L, 1); + + + + { + string _assetBundlePath = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.UnloadScene( _assetBundlePath ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Tick(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetLoader gen_to_be_invoked = (BF.AssetLoader)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Tick( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UnloadAllDelayAssets(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetLoader gen_to_be_invoked = (BF.AssetLoader)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.UnloadAllDelayAssets( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Clear(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetLoader gen_to_be_invoked = (BF.AssetLoader)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Clear( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ContainsAsset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetLoader gen_to_be_invoked = (BF.AssetLoader)translator.FastGetCSObj(L, 1); + + + + { + string _assetPath = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.ContainsAsset( _assetPath ); + LuaAPI.lua_pushboolean(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_AssetObjectBaseWrap.cs b/Assets/XLua/Gen/BF_AssetObjectBaseWrap.cs new file mode 100644 index 000000000..912b8dbc9 --- /dev/null +++ b/Assets/XLua/Gen/BF_AssetObjectBaseWrap.cs @@ -0,0 +1,262 @@ +#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 BFAssetObjectBaseWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.AssetObjectBase); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 6, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Tick", _m_Tick); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Unload", _m_Unload); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnloadCountdown", _m_UnloadCountdown); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Id", _g_get_Id); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AssetPath", _g_get_AssetPath); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AssetType", _g_get_AssetType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "RefCount", _g_get_RefCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "LoadStatus", _g_get_LoadStatus); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Asset", _g_get_Asset); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "LoadStatus", _s_set_LoadStatus); + + + 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, "BF.AssetObjectBase does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Tick(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetObjectBase gen_to_be_invoked = (BF.AssetObjectBase)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Tick( ); + 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_Unload(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetObjectBase gen_to_be_invoked = (BF.AssetObjectBase)translator.FastGetCSObj(L, 1); + + + + { + bool _immediately = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.Unload( _immediately ); + 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_UnloadCountdown(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetObjectBase gen_to_be_invoked = (BF.AssetObjectBase)translator.FastGetCSObj(L, 1); + + + + { + bool _immediately = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.UnloadCountdown( _immediately ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Id(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetObjectBase gen_to_be_invoked = (BF.AssetObjectBase)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushuint(L, gen_to_be_invoked.Id); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AssetPath(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetObjectBase gen_to_be_invoked = (BF.AssetObjectBase)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.AssetPath); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AssetType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetObjectBase gen_to_be_invoked = (BF.AssetObjectBase)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.AssetType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_RefCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetObjectBase gen_to_be_invoked = (BF.AssetObjectBase)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushuint(L, gen_to_be_invoked.RefCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_LoadStatus(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetObjectBase gen_to_be_invoked = (BF.AssetObjectBase)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.LoadStatus); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Asset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetObjectBase gen_to_be_invoked = (BF.AssetObjectBase)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Asset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_LoadStatus(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.AssetObjectBase gen_to_be_invoked = (BF.AssetObjectBase)translator.FastGetCSObj(L, 1); + BF.EAssetLoadStatus gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.LoadStatus = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_AssetObjectWrap.cs b/Assets/XLua/Gen/BF_AssetObjectWrap.cs new file mode 100644 index 000000000..8317c76c6 --- /dev/null +++ b/Assets/XLua/Gen/BF_AssetObjectWrap.cs @@ -0,0 +1,299 @@ +#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 BFAssetObjectWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.AssetObject); + Utils.BeginObjectRegister(type, L, translator, 0, 7, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadComplete", _m_LoadComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadAsync", _m_LoadAsync); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadSync", _m_LoadSync); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Unload", _m_Unload); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnloadAsset", _m_UnloadAsset); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "StartLoadAsset", _m_StartLoadAsset); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AssetDataBaseLoadEnd", _m_AssetDataBaseLoadEnd); + + + + + + 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) == 4 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING) && translator.Assignable(L, 3) && LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + string _assetPath = LuaAPI.lua_tostring(L, 2); + System.Type _type = (System.Type)translator.GetObject(L, 3, typeof(System.Type)); + bool _needSync = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = new BF.AssetObject(_assetPath, _type, _needSync); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 3 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING) && translator.Assignable(L, 3)) + { + string _assetPath = LuaAPI.lua_tostring(L, 2); + System.Type _type = (System.Type)translator.GetObject(L, 3, typeof(System.Type)); + + var gen_ret = new BF.AssetObject(_assetPath, _type); + 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.AssetObject constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetObject gen_to_be_invoked = (BF.AssetObject)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Object _asset = (UnityEngine.Object)translator.GetObject(L, 2, typeof(UnityEngine.Object)); + + gen_to_be_invoked.LoadComplete( _asset ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadAsync(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetObject gen_to_be_invoked = (BF.AssetObject)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.LoadAsync( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadSync(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetObject gen_to_be_invoked = (BF.AssetObject)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.LoadSync( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Unload(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetObject gen_to_be_invoked = (BF.AssetObject)translator.FastGetCSObj(L, 1); + + + + { + bool _immediately = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.Unload( _immediately ); + 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_UnloadAsset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetObject gen_to_be_invoked = (BF.AssetObject)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.UnloadAsset( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_StartLoadAsset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetObject gen_to_be_invoked = (BF.AssetObject)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.AssetBundle _ab = (UnityEngine.AssetBundle)translator.GetObject(L, 2, typeof(UnityEngine.AssetBundle)); + + gen_to_be_invoked.StartLoadAsset( _ab ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AssetDataBaseLoadEnd(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.AssetObject gen_to_be_invoked = (BF.AssetObject)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Object _obj = (UnityEngine.Object)translator.GetObject(L, 2, typeof(UnityEngine.Object)); + + gen_to_be_invoked.AssetDataBaseLoadEnd( _obj ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_AtlasWrap.cs b/Assets/XLua/Gen/BF_AtlasWrap.cs new file mode 100644 index 000000000..1c8fb5720 --- /dev/null +++ b/Assets/XLua/Gen/BF_AtlasWrap.cs @@ -0,0 +1,199 @@ +#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 BFAtlasWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.Atlas); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetIsHashCollision", _m_GetIsHashCollision); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSprite", _m_GetSprite); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBeforeSerialize", _m_OnBeforeSerialize); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnAfterDeserialize", _m_OnAfterDeserialize); + + + + + + 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.Atlas(); + 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.Atlas constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetIsHashCollision(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.Atlas gen_to_be_invoked = (BF.Atlas)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetIsHashCollision( ); + 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_GetSprite(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.Atlas gen_to_be_invoked = (BF.Atlas)translator.FastGetCSObj(L, 1); + + + + { + uint _spriteName = LuaAPI.xlua_touint(L, 2); + + var gen_ret = gen_to_be_invoked.GetSprite( _spriteName ); + 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_OnBeforeSerialize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.Atlas gen_to_be_invoked = (BF.Atlas)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.OnBeforeSerialize( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnAfterDeserialize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.Atlas gen_to_be_invoked = (BF.Atlas)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.OnAfterDeserialize( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_BFAccountInfoWrap.cs b/Assets/XLua/Gen/BF_BFAccountInfoWrap.cs new file mode 100644 index 000000000..b2f5a9a14 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFAccountInfoWrap.cs @@ -0,0 +1,301 @@ +#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 BFBFAccountInfoWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFAccountInfo); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 7, 7); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "code", _g_get_code); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "seq", _g_get_seq); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "uid", _g_get_uid); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "token", _g_get_token); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "gate", _g_get_gate); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ip", _g_get_ip); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bind", _g_get_bind); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "code", _s_set_code); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "seq", _s_set_seq); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "uid", _s_set_uid); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "token", _s_set_token); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "gate", _s_set_gate); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ip", _s_set_ip); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "bind", _s_set_bind); + + + 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.BFAccountInfo(); + 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.BFAccountInfo constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_code(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFAccountInfo gen_to_be_invoked = (BF.BFAccountInfo)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.code); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_seq(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFAccountInfo gen_to_be_invoked = (BF.BFAccountInfo)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.seq); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_uid(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFAccountInfo gen_to_be_invoked = (BF.BFAccountInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushint64(L, gen_to_be_invoked.uid); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_token(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFAccountInfo gen_to_be_invoked = (BF.BFAccountInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.token); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_gate(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFAccountInfo gen_to_be_invoked = (BF.BFAccountInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.gate); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ip(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFAccountInfo gen_to_be_invoked = (BF.BFAccountInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.ip); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bind(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFAccountInfo gen_to_be_invoked = (BF.BFAccountInfo)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.bind); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_code(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFAccountInfo gen_to_be_invoked = (BF.BFAccountInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.code = 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_seq(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFAccountInfo gen_to_be_invoked = (BF.BFAccountInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.seq = 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_uid(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFAccountInfo gen_to_be_invoked = (BF.BFAccountInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.uid = 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_token(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFAccountInfo gen_to_be_invoked = (BF.BFAccountInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.token = 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_gate(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFAccountInfo gen_to_be_invoked = (BF.BFAccountInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.gate = 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_ip(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFAccountInfo gen_to_be_invoked = (BF.BFAccountInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ip = 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_bind(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFAccountInfo gen_to_be_invoked = (BF.BFAccountInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.bind = (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/BF_BFAdmobSDKManagerWrap.cs b/Assets/XLua/Gen/BF_BFAdmobSDKManagerWrap.cs new file mode 100644 index 000000000..5f45a6c38 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFAdmobSDKManagerWrap.cs @@ -0,0 +1,527 @@ +#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 BFBFAdmobSDKManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFAdmobSDKManager); + Utils.BeginObjectRegister(type, L, translator, 0, 10, 5, 5); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ShowFullScreenAds", _m_ShowFullScreenAds); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryLoadRewardedAd", _m_TryLoadRewardedAd); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAdPlacement", _m_SetAdPlacement); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAdShowCallback", _m_SetAdShowCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAdLoadedCallback", _m_SetAdLoadedCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAdEarnedRewardCallback", _m_SetAdEarnedRewardCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ShowFullScreenAdFinish", _m_ShowFullScreenAdFinish); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AdLoadedFinish", _m_AdLoadedFinish); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "EarnedRewardFinish", _m_EarnedRewardFinish); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaShowCallback", _g_get_luaShowCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaLoadedCallback", _g_get_luaLoadedCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaEarnedRewardCallback", _g_get_luaEarnedRewardCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AdLoaded", _g_get_AdLoaded); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AdInitialized", _g_get_AdInitialized); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaShowCallback", _s_set_luaShowCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaLoadedCallback", _s_set_luaLoadedCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaEarnedRewardCallback", _s_set_luaEarnedRewardCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "AdLoaded", _s_set_AdLoaded); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "AdInitialized", _s_set_AdInitialized); + + + 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.BFAdmobSDKManager(); + 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.BFAdmobSDKManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFAdmobSDKManager gen_to_be_invoked = (BF.BFAdmobSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ShowFullScreenAds(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFAdmobSDKManager gen_to_be_invoked = (BF.BFAdmobSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ShowFullScreenAds( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TryLoadRewardedAd(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFAdmobSDKManager gen_to_be_invoked = (BF.BFAdmobSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.TryLoadRewardedAd( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAdPlacement(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFAdmobSDKManager gen_to_be_invoked = (BF.BFAdmobSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _placement = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SetAdPlacement( _placement ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAdShowCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFAdmobSDKManager gen_to_be_invoked = (BF.BFAdmobSDKManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetAdShowCallback( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAdLoadedCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFAdmobSDKManager gen_to_be_invoked = (BF.BFAdmobSDKManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetAdLoadedCallback( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAdEarnedRewardCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFAdmobSDKManager gen_to_be_invoked = (BF.BFAdmobSDKManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetAdEarnedRewardCallback( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ShowFullScreenAdFinish(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFAdmobSDKManager gen_to_be_invoked = (BF.BFAdmobSDKManager)translator.FastGetCSObj(L, 1); + + + + { + int _code = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.ShowFullScreenAdFinish( _code ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AdLoadedFinish(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFAdmobSDKManager gen_to_be_invoked = (BF.BFAdmobSDKManager)translator.FastGetCSObj(L, 1); + + + + { + int _code = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.AdLoadedFinish( _code ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_EarnedRewardFinish(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFAdmobSDKManager gen_to_be_invoked = (BF.BFAdmobSDKManager)translator.FastGetCSObj(L, 1); + + + + { + int _code = LuaAPI.xlua_tointeger(L, 2); + string _result = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.EarnedRewardFinish( _code, _result ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaShowCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFAdmobSDKManager gen_to_be_invoked = (BF.BFAdmobSDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaShowCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaLoadedCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFAdmobSDKManager gen_to_be_invoked = (BF.BFAdmobSDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaLoadedCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaEarnedRewardCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFAdmobSDKManager gen_to_be_invoked = (BF.BFAdmobSDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaEarnedRewardCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AdLoaded(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFAdmobSDKManager gen_to_be_invoked = (BF.BFAdmobSDKManager)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.AdLoaded); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AdInitialized(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFAdmobSDKManager gen_to_be_invoked = (BF.BFAdmobSDKManager)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.AdInitialized); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_luaShowCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFAdmobSDKManager gen_to_be_invoked = (BF.BFAdmobSDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaShowCallback = translator.GetDelegate>(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_luaLoadedCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFAdmobSDKManager gen_to_be_invoked = (BF.BFAdmobSDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaLoadedCallback = translator.GetDelegate>(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_luaEarnedRewardCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFAdmobSDKManager gen_to_be_invoked = (BF.BFAdmobSDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaEarnedRewardCallback = translator.GetDelegate>(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_AdLoaded(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFAdmobSDKManager gen_to_be_invoked = (BF.BFAdmobSDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.AdLoaded = 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_AdInitialized(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFAdmobSDKManager gen_to_be_invoked = (BF.BFAdmobSDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.AdInitialized = LuaAPI.lua_toboolean(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_BFCellWrap.cs b/Assets/XLua/Gen/BF_BFCellWrap.cs new file mode 100644 index 000000000..37bfecb32 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFCellWrap.cs @@ -0,0 +1,287 @@ +#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 BFBFCellWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFCell); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 7, 6); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AnchoredPosition", _g_get_AnchoredPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "SizeDelta", _g_get_SizeDelta); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Width", _g_get_Width); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Height", _g_get_Height); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "CachedRectTransform", _g_get_CachedRectTransform); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "dataIndex", _g_get_dataIndex); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "objIndex", _g_get_objIndex); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "AnchoredPosition", _s_set_AnchoredPosition); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "SizeDelta", _s_set_SizeDelta); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Width", _s_set_Width); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Height", _s_set_Height); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "dataIndex", _s_set_dataIndex); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "objIndex", _s_set_objIndex); + + + 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.BFCell(); + 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.BFCell constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AnchoredPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFCell gen_to_be_invoked = (BF.BFCell)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.AnchoredPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_SizeDelta(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFCell gen_to_be_invoked = (BF.BFCell)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.SizeDelta); + } 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.BFCell gen_to_be_invoked = (BF.BFCell)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(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.BFCell gen_to_be_invoked = (BF.BFCell)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(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 _g_get_CachedRectTransform(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFCell gen_to_be_invoked = (BF.BFCell)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.CachedRectTransform); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_dataIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFCell gen_to_be_invoked = (BF.BFCell)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.dataIndex); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_objIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFCell gen_to_be_invoked = (BF.BFCell)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.objIndex); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_AnchoredPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFCell gen_to_be_invoked = (BF.BFCell)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.AnchoredPosition = 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_SizeDelta(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFCell gen_to_be_invoked = (BF.BFCell)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.SizeDelta = 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_Width(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFCell gen_to_be_invoked = (BF.BFCell)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Width = (float)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_Height(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFCell gen_to_be_invoked = (BF.BFCell)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Height = (float)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_dataIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFCell gen_to_be_invoked = (BF.BFCell)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.dataIndex = 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_objIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFCell gen_to_be_invoked = (BF.BFCell)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.objIndex = 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_BFCircleLayoutWrap.cs b/Assets/XLua/Gen/BF_BFCircleLayoutWrap.cs new file mode 100644 index 000000000..3ab5447bc --- /dev/null +++ b/Assets/XLua/Gen/BF_BFCircleLayoutWrap.cs @@ -0,0 +1,250 @@ +#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 BFBFCircleLayoutWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFCircleLayout); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 4, 3); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Relayout", _m_Relayout); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPosByIndex", _m_GetPosByIndex); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ActiveCount", _g_get_ActiveCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "radius", _g_get_radius); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startAngle", _g_get_startAngle); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "angle", _g_get_angle); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "radius", _s_set_radius); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startAngle", _s_set_startAngle); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "angle", _s_set_angle); + + + 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.BFCircleLayout(); + 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.BFCircleLayout constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Relayout(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFCircleLayout gen_to_be_invoked = (BF.BFCircleLayout)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Relayout( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetPosByIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFCircleLayout gen_to_be_invoked = (BF.BFCircleLayout)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetPosByIndex( _index ); + translator.PushUnityEngineVector2(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_ActiveCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFCircleLayout gen_to_be_invoked = (BF.BFCircleLayout)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.ActiveCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_radius(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFCircleLayout gen_to_be_invoked = (BF.BFCircleLayout)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.radius); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startAngle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFCircleLayout gen_to_be_invoked = (BF.BFCircleLayout)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.startAngle); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_angle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFCircleLayout gen_to_be_invoked = (BF.BFCircleLayout)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.angle); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_radius(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFCircleLayout gen_to_be_invoked = (BF.BFCircleLayout)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.radius = (float)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_startAngle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFCircleLayout gen_to_be_invoked = (BF.BFCircleLayout)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.startAngle = (float)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_angle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFCircleLayout gen_to_be_invoked = (BF.BFCircleLayout)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.angle = (float)LuaAPI.lua_tonumber(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_BFEventBaseWrap.cs b/Assets/XLua/Gen/BF_BFEventBaseWrap.cs new file mode 100644 index 000000000..ab97fa797 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFEventBaseWrap.cs @@ -0,0 +1,200 @@ +#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 BFBFEventBaseWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFEventBase); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CallbackCount", _m_CallbackCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddListener", _m_AddListener); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveListener", _m_RemoveListener); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear); + + + + + + 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) == 2 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _length = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = new BF.BFEventBase(_length); + 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.BFEventBase constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CallbackCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFEventBase gen_to_be_invoked = (BF.BFEventBase)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.CallbackCount( ); + 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_AddListener(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFEventBase gen_to_be_invoked = (BF.BFEventBase)translator.FastGetCSObj(L, 1); + + + + { + System.Delegate _del = translator.GetDelegate(L, 2); + + gen_to_be_invoked.AddListener( _del ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveListener(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFEventBase gen_to_be_invoked = (BF.BFEventBase)translator.FastGetCSObj(L, 1); + + + + { + System.Delegate _del = translator.GetDelegate(L, 2); + + gen_to_be_invoked.RemoveListener( _del ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Clear(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFEventBase gen_to_be_invoked = (BF.BFEventBase)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Clear( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_BFEventWrap.cs b/Assets/XLua/Gen/BF_BFEventWrap.cs new file mode 100644 index 000000000..843630c60 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFEventWrap.cs @@ -0,0 +1,183 @@ +#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 BFBFEventWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFEvent); + Utils.BeginObjectRegister(type, L, translator, 2, 1, 0, 0); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__add", __AddMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__sub", __SubMeta); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Invoke", _m_Invoke); + + + + + + 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.BFEvent(); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _length = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = new BF.BFEvent(_length); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new BF.BFEvent(); + 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.BFEvent constructor!"); + + } + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __AddMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + BF.BFEvent leftside = (BF.BFEvent)translator.GetObject(L, 1, typeof(BF.BFEvent)); + System.Action rightside = translator.GetDelegate(L, 2); + + translator.Push(L, leftside + rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of + operator, need BF.BFEvent!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __SubMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + BF.BFEvent leftside = (BF.BFEvent)translator.GetObject(L, 1, typeof(BF.BFEvent)); + System.Action rightside = translator.GetDelegate(L, 2); + + translator.Push(L, leftside - rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of - operator, need BF.BFEvent!"); + + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Invoke(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFEvent gen_to_be_invoked = (BF.BFEvent)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Invoke( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_BFEvent_1_System_Collections_Generic_List_1_BF_BFFinger__Wrap.cs b/Assets/XLua/Gen/BF_BFEvent_1_System_Collections_Generic_List_1_BF_BFFinger__Wrap.cs new file mode 100644 index 000000000..2263fc1e1 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFEvent_1_System_Collections_Generic_List_1_BF_BFFinger__Wrap.cs @@ -0,0 +1,184 @@ +#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 BFBFEvent_1_SystemCollectionsGenericList_1_BFBFFinger__Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFEvent>); + Utils.BeginObjectRegister(type, L, translator, 2, 1, 0, 0); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__add", __AddMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__sub", __SubMeta); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Invoke", _m_Invoke); + + + + + + 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.BFEvent>(); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _length = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = new BF.BFEvent>(_length); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new BF.BFEvent>(); + 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.BFEvent> constructor!"); + + } + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __AddMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable>>(L, 1) && translator.Assignable>>(L, 2)) + { + BF.BFEvent> leftside = (BF.BFEvent>)translator.GetObject(L, 1, typeof(BF.BFEvent>)); + System.Action> rightside = translator.GetDelegate>>(L, 2); + + translator.Push(L, leftside + rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of + operator, need BF.BFEvent>!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __SubMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable>>(L, 1) && translator.Assignable>>(L, 2)) + { + BF.BFEvent> leftside = (BF.BFEvent>)translator.GetObject(L, 1, typeof(BF.BFEvent>)); + System.Action> rightside = translator.GetDelegate>>(L, 2); + + translator.Push(L, leftside - rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of - operator, need BF.BFEvent>!"); + + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Invoke(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFEvent> gen_to_be_invoked = (BF.BFEvent>)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.List _t = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.Invoke( _t ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_BFEvent_2_BF_SelectEventType_BF_BFFinger_Wrap.cs b/Assets/XLua/Gen/BF_BFEvent_2_BF_SelectEventType_BF_BFFinger_Wrap.cs new file mode 100644 index 000000000..5bef3af0f --- /dev/null +++ b/Assets/XLua/Gen/BF_BFEvent_2_BF_SelectEventType_BF_BFFinger_Wrap.cs @@ -0,0 +1,185 @@ +#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 BFBFEvent_2_BFSelectEventTypeBFBFFinger_Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFEvent); + Utils.BeginObjectRegister(type, L, translator, 2, 1, 0, 0); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__add", __AddMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__sub", __SubMeta); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Invoke", _m_Invoke); + + + + + + 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.BFEvent(); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _length = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = new BF.BFEvent(_length); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new BF.BFEvent(); + 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.BFEvent constructor!"); + + } + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __AddMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable>(L, 1) && translator.Assignable>(L, 2)) + { + BF.BFEvent leftside = (BF.BFEvent)translator.GetObject(L, 1, typeof(BF.BFEvent)); + System.Action rightside = translator.GetDelegate>(L, 2); + + translator.Push(L, leftside + rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of + operator, need BF.BFEvent!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __SubMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable>(L, 1) && translator.Assignable>(L, 2)) + { + BF.BFEvent leftside = (BF.BFEvent)translator.GetObject(L, 1, typeof(BF.BFEvent)); + System.Action rightside = translator.GetDelegate>(L, 2); + + translator.Push(L, leftside - rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of - operator, need BF.BFEvent!"); + + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Invoke(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFEvent gen_to_be_invoked = (BF.BFEvent)translator.FastGetCSObj(L, 1); + + + + { + BF.SelectEventType _t1;translator.Get(L, 2, out _t1); + BF.BFFinger _t2 = (BF.BFFinger)translator.GetObject(L, 3, typeof(BF.BFFinger)); + + gen_to_be_invoked.Invoke( _t1, _t2 ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_BFEvent_2_BF_TouchEventType_BF_BFFinger_Wrap.cs b/Assets/XLua/Gen/BF_BFEvent_2_BF_TouchEventType_BF_BFFinger_Wrap.cs new file mode 100644 index 000000000..63cfd5f77 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFEvent_2_BF_TouchEventType_BF_BFFinger_Wrap.cs @@ -0,0 +1,185 @@ +#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 BFBFEvent_2_BFTouchEventTypeBFBFFinger_Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFEvent); + Utils.BeginObjectRegister(type, L, translator, 2, 1, 0, 0); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__add", __AddMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__sub", __SubMeta); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Invoke", _m_Invoke); + + + + + + 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.BFEvent(); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _length = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = new BF.BFEvent(_length); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new BF.BFEvent(); + 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.BFEvent constructor!"); + + } + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __AddMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable>(L, 1) && translator.Assignable>(L, 2)) + { + BF.BFEvent leftside = (BF.BFEvent)translator.GetObject(L, 1, typeof(BF.BFEvent)); + System.Action rightside = translator.GetDelegate>(L, 2); + + translator.Push(L, leftside + rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of + operator, need BF.BFEvent!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __SubMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable>(L, 1) && translator.Assignable>(L, 2)) + { + BF.BFEvent leftside = (BF.BFEvent)translator.GetObject(L, 1, typeof(BF.BFEvent)); + System.Action rightside = translator.GetDelegate>(L, 2); + + translator.Push(L, leftside - rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of - operator, need BF.BFEvent!"); + + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Invoke(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFEvent gen_to_be_invoked = (BF.BFEvent)translator.FastGetCSObj(L, 1); + + + + { + BF.TouchEventType _t1;translator.Get(L, 2, out _t1); + BF.BFFinger _t2 = (BF.BFFinger)translator.GetObject(L, 3, typeof(BF.BFFinger)); + + gen_to_be_invoked.Invoke( _t1, _t2 ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_BFFingerSnapshotWrap.cs b/Assets/XLua/Gen/BF_BFFingerSnapshotWrap.cs new file mode 100644 index 000000000..f72071aef --- /dev/null +++ b/Assets/XLua/Gen/BF_BFFingerSnapshotWrap.cs @@ -0,0 +1,290 @@ +#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 BFBFFingerSnapshotWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFFingerSnapshot); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 2); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "age", _g_get_age); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "screenPos", _g_get_screenPos); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "age", _s_set_age); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "screenPos", _s_set_screenPos); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 5, 1, 1); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Pop", _m_Pop_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Push", _m_Push_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "TryGetScreenPos", _m_TryGetScreenPos_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetLowerIndex", _m_GetLowerIndex_xlua_st_); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "InactiveSnapshots", _g_get_InactiveSnapshots); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "InactiveSnapshots", _s_set_InactiveSnapshots); + + + 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.BFFingerSnapshot(); + 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.BFFingerSnapshot constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Pop_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = BF.BFFingerSnapshot.Pop( ); + 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_Push_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + BF.BFFingerSnapshot _snapshot = (BF.BFFingerSnapshot)translator.GetObject(L, 1, typeof(BF.BFFingerSnapshot)); + + BF.BFFingerSnapshot.Push( _snapshot ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TryGetScreenPos_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.Collections.Generic.List _snapshots = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + float _targetAge = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector2 _screenPos;translator.Get(L, 3, out _screenPos); + + var gen_ret = BF.BFFingerSnapshot.TryGetScreenPos( _snapshots, _targetAge, ref _screenPos ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.PushUnityEngineVector2(L, _screenPos); + translator.UpdateUnityEngineVector2(L, 3, _screenPos); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetLowerIndex_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.Collections.Generic.List _snapshots = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + float _targetAge = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = BF.BFFingerSnapshot.GetLowerIndex( _snapshots, _targetAge ); + 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 _g_get_age(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFingerSnapshot gen_to_be_invoked = (BF.BFFingerSnapshot)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(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_screenPos(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFingerSnapshot gen_to_be_invoked = (BF.BFFingerSnapshot)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.screenPos); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_InactiveSnapshots(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, BF.BFFingerSnapshot.InactiveSnapshots); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_age(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFingerSnapshot gen_to_be_invoked = (BF.BFFingerSnapshot)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.age = (float)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_screenPos(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFingerSnapshot gen_to_be_invoked = (BF.BFFingerSnapshot)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.screenPos = 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_InactiveSnapshots(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + BF.BFFingerSnapshot.InactiveSnapshots = (System.Collections.Generic.List)translator.GetObject(L, 1, 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/BF_BFFingerWrap.cs b/Assets/XLua/Gen/BF_BFFingerWrap.cs new file mode 100644 index 000000000..ad6a9860c --- /dev/null +++ b/Assets/XLua/Gen/BF_BFFingerWrap.cs @@ -0,0 +1,1571 @@ +#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 BFBFFingerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFFinger); + Utils.BeginObjectRegister(type, L, translator, 0, 20, 29, 17); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetRay", _m_GetRay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetStartRay", _m_GetStartRay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSnapshotScreenDelta", _m_GetSnapshotScreenDelta); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSnapshotScreenPosition", _m_GetSnapshotScreenPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSnapshotWorldPosition", _m_GetSnapshotWorldPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetRadians", _m_GetRadians); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetDegrees", _m_GetDegrees); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetLastRadians", _m_GetLastRadians); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetLastDegrees", _m_GetLastDegrees); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetDeltaRadians", _m_GetDeltaRadians); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetDeltaDegrees", _m_GetDeltaDegrees); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetScreenDistance", _m_GetScreenDistance); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetLastScreenDistance", _m_GetLastScreenDistance); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetStartScreenDistance", _m_GetStartScreenDistance); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetStartWorldPosition", _m_GetStartWorldPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetLastWorldPosition", _m_GetLastWorldPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetWorldPosition", _m_GetWorldPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetWorldDelta", _m_GetWorldDelta); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearSnapshots", _m_ClearSnapshots); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RecordSnapshot", _m_RecordSnapshot); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "StartLayer", _g_get_StartLayer); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsActive", _g_get_IsActive); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "SnapshotDuration", _g_get_SnapshotDuration); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsOverTargetLayer", _g_get_IsOverTargetLayer); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "TargetTrans", _g_get_TargetTrans); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Hit", _g_get_Hit); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Down", _g_get_Down); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Up", _g_get_Up); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Move", _g_get_Move); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "LastSnapshotScreenDelta", _g_get_LastSnapshotScreenDelta); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ScreenDelta", _g_get_ScreenDelta); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "SlideScreenDelta", _g_get_SlideScreenDelta); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "index", _g_get_index); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "age", _g_get_age); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "touching", _g_get_touching); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lastTouching", _g_get_lastTouching); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "hit", _g_get_hit); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "hitCount", _g_get_hitCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "slide", _g_get_slide); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "dead", _g_get_dead); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "pressure", _g_get_pressure); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lastPressure", _g_get_lastPressure); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startScreenPos", _g_get_startScreenPos); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lastScreenPos", _g_get_lastScreenPos); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "curScreenPos", _g_get_curScreenPos); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startOverTargetLayer", _g_get_startOverTargetLayer); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startTargetTrans", _g_get_startTargetTrans); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "cantTriggerHit", _g_get_cantTriggerHit); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "snapshotList", _g_get_snapshotList); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "index", _s_set_index); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "age", _s_set_age); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "touching", _s_set_touching); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "lastTouching", _s_set_lastTouching); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "hit", _s_set_hit); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "hitCount", _s_set_hitCount); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "slide", _s_set_slide); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "dead", _s_set_dead); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "pressure", _s_set_pressure); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "lastPressure", _s_set_lastPressure); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startScreenPos", _s_set_startScreenPos); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "lastScreenPos", _s_set_lastScreenPos); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "curScreenPos", _s_set_curScreenPos); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startOverTargetLayer", _s_set_startOverTargetLayer); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startTargetTrans", _s_set_startTargetTrans); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "cantTriggerHit", _s_set_cantTriggerHit); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "snapshotList", _s_set_snapshotList); + + + 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.BFFinger(); + 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.BFFinger constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetRay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 2, typeof(UnityEngine.Camera)); + + var gen_ret = gen_to_be_invoked.GetRay( _camera ); + translator.PushUnityEngineRay(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.GetRay( ); + translator.PushUnityEngineRay(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.BFFinger.GetRay!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetStartRay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 2, typeof(UnityEngine.Camera)); + + var gen_ret = gen_to_be_invoked.GetStartRay( _camera ); + translator.PushUnityEngineRay(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.GetStartRay( ); + translator.PushUnityEngineRay(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.BFFinger.GetStartRay!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetSnapshotScreenDelta(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + + + + { + float _deltaTime = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.GetSnapshotScreenDelta( _deltaTime ); + translator.PushUnityEngineVector2(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_GetSnapshotScreenPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + + + + { + float _targetAge = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.GetSnapshotScreenPosition( _targetAge ); + translator.PushUnityEngineVector2(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_GetSnapshotWorldPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + float _targetAge = (float)LuaAPI.lua_tonumber(L, 2); + float _distance = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 4, typeof(UnityEngine.Camera)); + + var gen_ret = gen_to_be_invoked.GetSnapshotWorldPosition( _targetAge, _distance, _camera ); + translator.PushUnityEngineVector3(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _targetAge = (float)LuaAPI.lua_tonumber(L, 2); + float _distance = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.GetSnapshotWorldPosition( _targetAge, _distance ); + translator.PushUnityEngineVector3(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.BFFinger.GetSnapshotWorldPosition!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetRadians(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector2 _referencePoint;translator.Get(L, 2, out _referencePoint); + + var gen_ret = gen_to_be_invoked.GetRadians( _referencePoint ); + LuaAPI.lua_pushnumber(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_GetDegrees(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector2 _referencePoint;translator.Get(L, 2, out _referencePoint); + + var gen_ret = gen_to_be_invoked.GetDegrees( _referencePoint ); + LuaAPI.lua_pushnumber(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_GetLastRadians(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector2 _referencePoint;translator.Get(L, 2, out _referencePoint); + + var gen_ret = gen_to_be_invoked.GetLastRadians( _referencePoint ); + LuaAPI.lua_pushnumber(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_GetLastDegrees(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector2 _referencePoint;translator.Get(L, 2, out _referencePoint); + + var gen_ret = gen_to_be_invoked.GetLastDegrees( _referencePoint ); + LuaAPI.lua_pushnumber(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_GetDeltaRadians(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector2 _referencePoint;translator.Get(L, 2, out _referencePoint); + + var gen_ret = gen_to_be_invoked.GetDeltaRadians( _referencePoint ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector2 _referencePoint;translator.Get(L, 2, out _referencePoint); + UnityEngine.Vector2 _lastReferencePoint;translator.Get(L, 3, out _lastReferencePoint); + + var gen_ret = gen_to_be_invoked.GetDeltaRadians( _referencePoint, _lastReferencePoint ); + LuaAPI.lua_pushnumber(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.BFFinger.GetDeltaRadians!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetDeltaDegrees(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector2 _referencePoint;translator.Get(L, 2, out _referencePoint); + + var gen_ret = gen_to_be_invoked.GetDeltaDegrees( _referencePoint ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector2 _referencePoint;translator.Get(L, 2, out _referencePoint); + UnityEngine.Vector2 _lastReferencePoint;translator.Get(L, 3, out _lastReferencePoint); + + var gen_ret = gen_to_be_invoked.GetDeltaDegrees( _referencePoint, _lastReferencePoint ); + LuaAPI.lua_pushnumber(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.BFFinger.GetDeltaDegrees!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetScreenDistance(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector2 _point;translator.Get(L, 2, out _point); + + var gen_ret = gen_to_be_invoked.GetScreenDistance( _point ); + LuaAPI.lua_pushnumber(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_GetLastScreenDistance(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector2 _point;translator.Get(L, 2, out _point); + + var gen_ret = gen_to_be_invoked.GetLastScreenDistance( _point ); + LuaAPI.lua_pushnumber(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_GetStartScreenDistance(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector2 _point;translator.Get(L, 2, out _point); + + var gen_ret = gen_to_be_invoked.GetStartScreenDistance( _point ); + LuaAPI.lua_pushnumber(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_GetStartWorldPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + float _distance = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 3, typeof(UnityEngine.Camera)); + + var gen_ret = gen_to_be_invoked.GetStartWorldPosition( _distance, _camera ); + translator.PushUnityEngineVector3(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _distance = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.GetStartWorldPosition( _distance ); + translator.PushUnityEngineVector3(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.BFFinger.GetStartWorldPosition!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetLastWorldPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + float _distance = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 3, typeof(UnityEngine.Camera)); + + var gen_ret = gen_to_be_invoked.GetLastWorldPosition( _distance, _camera ); + translator.PushUnityEngineVector3(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _distance = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.GetLastWorldPosition( _distance ); + translator.PushUnityEngineVector3(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.BFFinger.GetLastWorldPosition!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetWorldPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + float _distance = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 3, typeof(UnityEngine.Camera)); + + var gen_ret = gen_to_be_invoked.GetWorldPosition( _distance, _camera ); + translator.PushUnityEngineVector3(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _distance = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.GetWorldPosition( _distance ); + translator.PushUnityEngineVector3(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.BFFinger.GetWorldPosition!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetWorldDelta(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + float _distance = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 3, typeof(UnityEngine.Camera)); + + var gen_ret = gen_to_be_invoked.GetWorldDelta( _distance, _camera ); + translator.PushUnityEngineVector3(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _distance = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.GetWorldDelta( _distance ); + translator.PushUnityEngineVector3(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + float _lastDistance = (float)LuaAPI.lua_tonumber(L, 2); + float _distance = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 4, typeof(UnityEngine.Camera)); + + var gen_ret = gen_to_be_invoked.GetWorldDelta( _lastDistance, _distance, _camera ); + translator.PushUnityEngineVector3(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _lastDistance = (float)LuaAPI.lua_tonumber(L, 2); + float _distance = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.GetWorldDelta( _lastDistance, _distance ); + translator.PushUnityEngineVector3(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.BFFinger.GetWorldDelta!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearSnapshots(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _count = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.ClearSnapshots( _count ); + + + + return 0; + } + if(gen_param_count == 1) + { + + gen_to_be_invoked.ClearSnapshots( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.BFFinger.ClearSnapshots!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RecordSnapshot(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RecordSnapshot( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_StartLayer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.StartLayer); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsActive(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsActive); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_SnapshotDuration(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.SnapshotDuration); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsOverTargetLayer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsOverTargetLayer); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_TargetTrans(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.TargetTrans); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Hit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.Hit); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Down(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.Down); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Up(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.Up); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Move(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.Move); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_LastSnapshotScreenDelta(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.LastSnapshotScreenDelta); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ScreenDelta(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.ScreenDelta); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_SlideScreenDelta(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.SlideScreenDelta); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_index(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.index); + } 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); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(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_touching(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.touching); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lastTouching(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.lastTouching); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_hit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hit); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_hitCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.hitCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_slide(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.slide); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_dead(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.dead); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_pressure(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.pressure); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lastPressure(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.lastPressure); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startScreenPos(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.startScreenPos); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lastScreenPos(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.lastScreenPos); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_curScreenPos(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.curScreenPos); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startOverTargetLayer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.startOverTargetLayer); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startTargetTrans(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.startTargetTrans); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cantTriggerHit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.cantTriggerHit); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_snapshotList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.snapshotList); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_index(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.index = 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_age(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.age = (float)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_touching(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.touching = 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_lastTouching(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.lastTouching = 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_hit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.hit = 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_hitCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.hitCount = 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_slide(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.slide = 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_dead(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.dead = 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_pressure(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.pressure = (float)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_lastPressure(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.lastPressure = (float)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_startScreenPos(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.startScreenPos = 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_lastScreenPos(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.lastScreenPos = 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_curScreenPos(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.curScreenPos = 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_startOverTargetLayer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.startOverTargetLayer = 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_startTargetTrans(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.startTargetTrans = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_cantTriggerHit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.cantTriggerHit = 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_snapshotList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFFinger gen_to_be_invoked = (BF.BFFinger)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.snapshotList = (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/BF_BFGateInfoWrap.cs b/Assets/XLua/Gen/BF_BFGateInfoWrap.cs new file mode 100644 index 000000000..dcdeeeec5 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFGateInfoWrap.cs @@ -0,0 +1,212 @@ +#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 BFBFGateInfoWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFGateInfo); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 4, 4); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mainDomain", _g_get_mainDomain); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mainPort", _g_get_mainPort); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "chatDomain", _g_get_chatDomain); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "chatPort", _g_get_chatPort); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "mainDomain", _s_set_mainDomain); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "mainPort", _s_set_mainPort); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "chatDomain", _s_set_chatDomain); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "chatPort", _s_set_chatPort); + + + 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) == 5 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + string _mainDomain = LuaAPI.lua_tostring(L, 2); + int _mainPort = LuaAPI.xlua_tointeger(L, 3); + string _chatDomain = LuaAPI.lua_tostring(L, 4); + int _chatPort = LuaAPI.xlua_tointeger(L, 5); + + var gen_ret = new BF.BFGateInfo(_mainDomain, _mainPort, _chatDomain, _chatPort); + 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.BFGateInfo constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mainDomain(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFGateInfo gen_to_be_invoked = (BF.BFGateInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.mainDomain); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mainPort(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFGateInfo gen_to_be_invoked = (BF.BFGateInfo)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.mainPort); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_chatDomain(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFGateInfo gen_to_be_invoked = (BF.BFGateInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.chatDomain); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_chatPort(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFGateInfo gen_to_be_invoked = (BF.BFGateInfo)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.chatPort); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_mainDomain(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFGateInfo gen_to_be_invoked = (BF.BFGateInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.mainDomain = 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_mainPort(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFGateInfo gen_to_be_invoked = (BF.BFGateInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.mainPort = 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_chatDomain(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFGateInfo gen_to_be_invoked = (BF.BFGateInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.chatDomain = 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_chatPort(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFGateInfo gen_to_be_invoked = (BF.BFGateInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.chatPort = 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_BFGestureWrap.cs b/Assets/XLua/Gen/BF_BFGestureWrap.cs new file mode 100644 index 000000000..ec674cfe4 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFGestureWrap.cs @@ -0,0 +1,615 @@ +#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 BFBFGestureWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFGesture); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 12, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetScreenCenter", _m_GetScreenCenter_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetLastScreenCenter", _m_GetLastScreenCenter_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetStartScreenCenter", _m_GetStartScreenCenter_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetScreenDelta", _m_GetScreenDelta_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetWorldDelta", _m_GetWorldDelta_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetScreenDistance", _m_GetScreenDistance_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetLastScreenDistance", _m_GetLastScreenDistance_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetStartScreenDistance", _m_GetStartScreenDistance_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetPinchScale", _m_GetPinchScale_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetTwistDegrees", _m_GetTwistDegrees_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetTwistRadians", _m_GetTwistRadians_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "BF.BFGesture does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetScreenCenter_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 0) + { + + var gen_ret = BF.BFGesture.GetScreenCenter( ); + translator.PushUnityEngineVector2(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable>(L, 1)) + { + System.Collections.Generic.List _fingers = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + + var gen_ret = BF.BFGesture.GetScreenCenter( _fingers ); + translator.PushUnityEngineVector2(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.BFGesture.GetScreenCenter!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetLastScreenCenter_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 0) + { + + var gen_ret = BF.BFGesture.GetLastScreenCenter( ); + translator.PushUnityEngineVector2(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable>(L, 1)) + { + System.Collections.Generic.List _fingers = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + + var gen_ret = BF.BFGesture.GetLastScreenCenter( _fingers ); + translator.PushUnityEngineVector2(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.BFGesture.GetLastScreenCenter!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetStartScreenCenter_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 0) + { + + var gen_ret = BF.BFGesture.GetStartScreenCenter( ); + translator.PushUnityEngineVector2(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable>(L, 1)) + { + System.Collections.Generic.List _fingers = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + + var gen_ret = BF.BFGesture.GetStartScreenCenter( _fingers ); + translator.PushUnityEngineVector2(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.BFGesture.GetStartScreenCenter!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetScreenDelta_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 0) + { + + var gen_ret = BF.BFGesture.GetScreenDelta( ); + translator.PushUnityEngineVector2(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable>(L, 1)) + { + System.Collections.Generic.List _fingers = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + + var gen_ret = BF.BFGesture.GetScreenDelta( _fingers ); + translator.PushUnityEngineVector2(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.BFGesture.GetScreenDelta!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetWorldDelta_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + float _distance = (float)LuaAPI.lua_tonumber(L, 1); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 2, typeof(UnityEngine.Camera)); + + var gen_ret = BF.BFGesture.GetWorldDelta( _distance, _camera ); + translator.PushUnityEngineVector3(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + float _distance = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = BF.BFGesture.GetWorldDelta( _distance ); + translator.PushUnityEngineVector3(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable>(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + System.Collections.Generic.List _fingers = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + float _distance = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 3, typeof(UnityEngine.Camera)); + + var gen_ret = BF.BFGesture.GetWorldDelta( _fingers, _distance, _camera ); + translator.PushUnityEngineVector3(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable>(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + System.Collections.Generic.List _fingers = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + float _distance = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = BF.BFGesture.GetWorldDelta( _fingers, _distance ); + translator.PushUnityEngineVector3(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.BFGesture.GetWorldDelta!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetScreenDistance_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 0) + { + + var gen_ret = BF.BFGesture.GetScreenDistance( ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable>(L, 1)) + { + System.Collections.Generic.List _fingers = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + + var gen_ret = BF.BFGesture.GetScreenDistance( _fingers ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable>(L, 1)&& translator.Assignable(L, 2)) + { + System.Collections.Generic.List _fingers = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + UnityEngine.Vector2 _center;translator.Get(L, 2, out _center); + + var gen_ret = BF.BFGesture.GetScreenDistance( _fingers, _center ); + LuaAPI.lua_pushnumber(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.BFGesture.GetScreenDistance!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetLastScreenDistance_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 0) + { + + var gen_ret = BF.BFGesture.GetLastScreenDistance( ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable>(L, 1)) + { + System.Collections.Generic.List _fingers = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + + var gen_ret = BF.BFGesture.GetLastScreenDistance( _fingers ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable>(L, 1)&& translator.Assignable(L, 2)) + { + System.Collections.Generic.List _fingers = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + UnityEngine.Vector2 _center;translator.Get(L, 2, out _center); + + var gen_ret = BF.BFGesture.GetLastScreenDistance( _fingers, _center ); + LuaAPI.lua_pushnumber(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.BFGesture.GetLastScreenDistance!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetStartScreenDistance_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 0) + { + + var gen_ret = BF.BFGesture.GetStartScreenDistance( ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable>(L, 1)) + { + System.Collections.Generic.List _fingers = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + + var gen_ret = BF.BFGesture.GetStartScreenDistance( _fingers ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable>(L, 1)&& translator.Assignable(L, 2)) + { + System.Collections.Generic.List _fingers = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + UnityEngine.Vector2 _center;translator.Get(L, 2, out _center); + + var gen_ret = BF.BFGesture.GetStartScreenDistance( _fingers, _center ); + LuaAPI.lua_pushnumber(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.BFGesture.GetStartScreenDistance!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetPinchScale_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)) + { + bool _useWheel = LuaAPI.lua_toboolean(L, 1); + + var gen_ret = BF.BFGesture.GetPinchScale( _useWheel ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 0) + { + + var gen_ret = BF.BFGesture.GetPinchScale( ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable>(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + System.Collections.Generic.List _fingers = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + bool _useWheel = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = BF.BFGesture.GetPinchScale( _fingers, _useWheel ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable>(L, 1)) + { + System.Collections.Generic.List _fingers = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + + var gen_ret = BF.BFGesture.GetPinchScale( _fingers ); + LuaAPI.lua_pushnumber(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.BFGesture.GetPinchScale!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetTwistDegrees_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 0) + { + + var gen_ret = BF.BFGesture.GetTwistDegrees( ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable>(L, 1)) + { + System.Collections.Generic.List _fingers = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + + var gen_ret = BF.BFGesture.GetTwistDegrees( _fingers ); + LuaAPI.lua_pushnumber(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.BFGesture.GetTwistDegrees!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetTwistRadians_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 0) + { + + var gen_ret = BF.BFGesture.GetTwistRadians( ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable>(L, 1)) + { + System.Collections.Generic.List _fingers = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + + var gen_ret = BF.BFGesture.GetTwistRadians( _fingers ); + LuaAPI.lua_pushnumber(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.BFGesture.GetTwistRadians!"); + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_BFGraphicFlipWrap.cs b/Assets/XLua/Gen/BF_BFGraphicFlipWrap.cs new file mode 100644 index 000000000..ff3f09cff --- /dev/null +++ b/Assets/XLua/Gen/BF_BFGraphicFlipWrap.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 BFBFGraphicFlipWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFGraphicFlip); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 2, 2); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ModifyMesh", _m_ModifyMesh); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "horizontal", _g_get_horizontal); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "vertical", _g_get_vertical); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "horizontal", _s_set_horizontal); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "vertical", _s_set_vertical); + + + 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.BFGraphicFlip(); + 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.BFGraphicFlip constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ModifyMesh(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFGraphicFlip gen_to_be_invoked = (BF.BFGraphicFlip)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.UI.VertexHelper _verts = (UnityEngine.UI.VertexHelper)translator.GetObject(L, 2, typeof(UnityEngine.UI.VertexHelper)); + + gen_to_be_invoked.ModifyMesh( _verts ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_horizontal(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFGraphicFlip gen_to_be_invoked = (BF.BFGraphicFlip)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.horizontal); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_vertical(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFGraphicFlip gen_to_be_invoked = (BF.BFGraphicFlip)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.vertical); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_horizontal(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFGraphicFlip gen_to_be_invoked = (BF.BFGraphicFlip)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.horizontal = 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_vertical(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFGraphicFlip gen_to_be_invoked = (BF.BFGraphicFlip)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.vertical = LuaAPI.lua_toboolean(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_BFGridLayoutWrap.cs b/Assets/XLua/Gen/BF_BFGridLayoutWrap.cs new file mode 100644 index 000000000..b3b735d93 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFGridLayoutWrap.cs @@ -0,0 +1,329 @@ +#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 BFBFGridLayoutWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFGridLayout); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 5, 5); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshLayout", _m_RefreshLayout); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetVerticalSize", _m_GetVerticalSize); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHorizontalSize", _m_GetHorizontalSize); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Spaceing", _g_get_Spaceing); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "CellSize", _g_get_CellSize); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "StartCorner", _g_get_StartCorner); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ConstraintType", _g_get_ConstraintType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ConstraintCount", _g_get_ConstraintCount); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Spaceing", _s_set_Spaceing); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "CellSize", _s_set_CellSize); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "StartCorner", _s_set_StartCorner); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ConstraintType", _s_set_ConstraintType); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ConstraintCount", _s_set_ConstraintCount); + + + 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.BFGridLayout(); + 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.BFGridLayout constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RefreshLayout(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFGridLayout gen_to_be_invoked = (BF.BFGridLayout)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RefreshLayout( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetVerticalSize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFGridLayout gen_to_be_invoked = (BF.BFGridLayout)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetVerticalSize( ); + LuaAPI.lua_pushnumber(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_GetHorizontalSize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFGridLayout gen_to_be_invoked = (BF.BFGridLayout)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetHorizontalSize( ); + LuaAPI.lua_pushnumber(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_Spaceing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFGridLayout gen_to_be_invoked = (BF.BFGridLayout)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.Spaceing); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_CellSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFGridLayout gen_to_be_invoked = (BF.BFGridLayout)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.CellSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_StartCorner(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFGridLayout gen_to_be_invoked = (BF.BFGridLayout)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.StartCorner); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ConstraintType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFGridLayout gen_to_be_invoked = (BF.BFGridLayout)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.ConstraintType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ConstraintCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFGridLayout gen_to_be_invoked = (BF.BFGridLayout)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.ConstraintCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Spaceing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFGridLayout gen_to_be_invoked = (BF.BFGridLayout)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.Spaceing = 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_CellSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFGridLayout gen_to_be_invoked = (BF.BFGridLayout)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.CellSize = 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_StartCorner(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFGridLayout gen_to_be_invoked = (BF.BFGridLayout)translator.FastGetCSObj(L, 1); + BF.BFGridLayout.Corner gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.StartCorner = 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_ConstraintType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFGridLayout gen_to_be_invoked = (BF.BFGridLayout)translator.FastGetCSObj(L, 1); + BF.BFGridLayout.Constraint gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.ConstraintType = 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_ConstraintCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFGridLayout gen_to_be_invoked = (BF.BFGridLayout)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ConstraintCount = 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_BFHWAdSDKManagerWrap.cs b/Assets/XLua/Gen/BF_BFHWAdSDKManagerWrap.cs new file mode 100644 index 000000000..dc84546f7 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFHWAdSDKManagerWrap.cs @@ -0,0 +1,498 @@ +#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 BFBFHWAdSDKManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFHWAdSDKManager); + Utils.BeginObjectRegister(type, L, translator, 0, 9, 5, 5); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ShowFullScreenAds", _m_ShowFullScreenAds); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryLoadRewardedAd", _m_TryLoadRewardedAd); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAdShowCallback", _m_SetAdShowCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAdLoadedCallback", _m_SetAdLoadedCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAdEarnedRewardCallback", _m_SetAdEarnedRewardCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ShowFullScreenAdFinish", _m_ShowFullScreenAdFinish); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AdLoadedFinish", _m_AdLoadedFinish); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "EarnedRewardFinish", _m_EarnedRewardFinish); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaShowCallback", _g_get_luaShowCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaLoadedCallback", _g_get_luaLoadedCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaEarnedRewardCallback", _g_get_luaEarnedRewardCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AdLoaded", _g_get_AdLoaded); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AdInitialized", _g_get_AdInitialized); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaShowCallback", _s_set_luaShowCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaLoadedCallback", _s_set_luaLoadedCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaEarnedRewardCallback", _s_set_luaEarnedRewardCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "AdLoaded", _s_set_AdLoaded); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "AdInitialized", _s_set_AdInitialized); + + + 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.BFHWAdSDKManager(); + 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.BFHWAdSDKManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFHWAdSDKManager gen_to_be_invoked = (BF.BFHWAdSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ShowFullScreenAds(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFHWAdSDKManager gen_to_be_invoked = (BF.BFHWAdSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ShowFullScreenAds( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TryLoadRewardedAd(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFHWAdSDKManager gen_to_be_invoked = (BF.BFHWAdSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.TryLoadRewardedAd( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAdShowCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFHWAdSDKManager gen_to_be_invoked = (BF.BFHWAdSDKManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetAdShowCallback( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAdLoadedCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFHWAdSDKManager gen_to_be_invoked = (BF.BFHWAdSDKManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetAdLoadedCallback( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAdEarnedRewardCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFHWAdSDKManager gen_to_be_invoked = (BF.BFHWAdSDKManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetAdEarnedRewardCallback( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ShowFullScreenAdFinish(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFHWAdSDKManager gen_to_be_invoked = (BF.BFHWAdSDKManager)translator.FastGetCSObj(L, 1); + + + + { + int _code = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.ShowFullScreenAdFinish( _code ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AdLoadedFinish(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFHWAdSDKManager gen_to_be_invoked = (BF.BFHWAdSDKManager)translator.FastGetCSObj(L, 1); + + + + { + int _code = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.AdLoadedFinish( _code ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_EarnedRewardFinish(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFHWAdSDKManager gen_to_be_invoked = (BF.BFHWAdSDKManager)translator.FastGetCSObj(L, 1); + + + + { + int _code = LuaAPI.xlua_tointeger(L, 2); + string _result = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.EarnedRewardFinish( _code, _result ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaShowCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFHWAdSDKManager gen_to_be_invoked = (BF.BFHWAdSDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaShowCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaLoadedCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFHWAdSDKManager gen_to_be_invoked = (BF.BFHWAdSDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaLoadedCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaEarnedRewardCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFHWAdSDKManager gen_to_be_invoked = (BF.BFHWAdSDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaEarnedRewardCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AdLoaded(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFHWAdSDKManager gen_to_be_invoked = (BF.BFHWAdSDKManager)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.AdLoaded); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AdInitialized(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFHWAdSDKManager gen_to_be_invoked = (BF.BFHWAdSDKManager)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.AdInitialized); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_luaShowCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFHWAdSDKManager gen_to_be_invoked = (BF.BFHWAdSDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaShowCallback = translator.GetDelegate>(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_luaLoadedCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFHWAdSDKManager gen_to_be_invoked = (BF.BFHWAdSDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaLoadedCallback = translator.GetDelegate>(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_luaEarnedRewardCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFHWAdSDKManager gen_to_be_invoked = (BF.BFHWAdSDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaEarnedRewardCallback = translator.GetDelegate>(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_AdLoaded(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFHWAdSDKManager gen_to_be_invoked = (BF.BFHWAdSDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.AdLoaded = 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_AdInitialized(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFHWAdSDKManager gen_to_be_invoked = (BF.BFHWAdSDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.AdInitialized = LuaAPI.lua_toboolean(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_BFHWPaySDKManagerWrap.cs b/Assets/XLua/Gen/BF_BFHWPaySDKManagerWrap.cs new file mode 100644 index 000000000..aa4076e80 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFHWPaySDKManagerWrap.cs @@ -0,0 +1,547 @@ +#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 BFBFHWPaySDKManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFHWPaySDKManager); + Utils.BeginObjectRegister(type, L, translator, 0, 11, 5, 4); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CheckStoreValid", _m_CheckStoreValid); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CheckStoreValidComplete", _m_CheckStoreValidComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "QueryProductInfo", _m_QueryProductInfo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "QueryProductComplete", _m_QueryProductComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Pay", _m_Pay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PayComplete", _m_PayComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ConsumePurchase", _m_ConsumePurchase); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ConsumeComplete", _m_ConsumeComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "QueryUncompleteOrder", _m_QueryUncompleteOrder); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "QueryUncompleteOrderFinish", _m_QueryUncompleteOrderFinish); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "StoreValid", _g_get_StoreValid); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaPayCallback", _g_get_luaPayCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaQueryProductCallback", _g_get_luaQueryProductCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaQueryUncompleteOrderCallback", _g_get_luaQueryUncompleteOrderCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaConsumeCallback", _g_get_luaConsumeCallback); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaPayCallback", _s_set_luaPayCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaQueryProductCallback", _s_set_luaQueryProductCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaQueryUncompleteOrderCallback", _s_set_luaQueryUncompleteOrderCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaConsumeCallback", _s_set_luaConsumeCallback); + + + 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.BFHWPaySDKManager(); + 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.BFHWPaySDKManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFHWPaySDKManager gen_to_be_invoked = (BF.BFHWPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CheckStoreValid(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFHWPaySDKManager gen_to_be_invoked = (BF.BFHWPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CheckStoreValid( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CheckStoreValidComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFHWPaySDKManager gen_to_be_invoked = (BF.BFHWPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + bool _success = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.CheckStoreValidComplete( _success ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_QueryProductInfo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFHWPaySDKManager gen_to_be_invoked = (BF.BFHWPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _productJson = LuaAPI.lua_tostring(L, 2); + System.Action _callback = translator.GetDelegate>(L, 3); + + gen_to_be_invoked.QueryProductInfo( _productJson, _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_QueryProductComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFHWPaySDKManager gen_to_be_invoked = (BF.BFHWPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + bool _succ = LuaAPI.lua_toboolean(L, 2); + string _result = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.QueryProductComplete( _succ, _result ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Pay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFHWPaySDKManager gen_to_be_invoked = (BF.BFHWPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _payType = LuaAPI.lua_tostring(L, 2); + string _productId = LuaAPI.lua_tostring(L, 3); + string _customMsg = LuaAPI.lua_tostring(L, 4); + System.Action _callback = translator.GetDelegate>(L, 5); + + gen_to_be_invoked.Pay( _payType, _productId, _customMsg, _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PayComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFHWPaySDKManager gen_to_be_invoked = (BF.BFHWPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + int _code = LuaAPI.xlua_tointeger(L, 2); + string _result = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.PayComplete( _code, _result ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ConsumePurchase(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFHWPaySDKManager gen_to_be_invoked = (BF.BFHWPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _token = LuaAPI.lua_tostring(L, 2); + System.Action _callback = translator.GetDelegate>(L, 3); + + gen_to_be_invoked.ConsumePurchase( _token, _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ConsumeComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFHWPaySDKManager gen_to_be_invoked = (BF.BFHWPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + int _code = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.ConsumeComplete( _code ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_QueryUncompleteOrder(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFHWPaySDKManager gen_to_be_invoked = (BF.BFHWPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.QueryUncompleteOrder( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_QueryUncompleteOrderFinish(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFHWPaySDKManager gen_to_be_invoked = (BF.BFHWPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _result = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.QueryUncompleteOrderFinish( _result ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_StoreValid(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFHWPaySDKManager gen_to_be_invoked = (BF.BFHWPaySDKManager)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.StoreValid); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaPayCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFHWPaySDKManager gen_to_be_invoked = (BF.BFHWPaySDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaPayCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaQueryProductCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFHWPaySDKManager gen_to_be_invoked = (BF.BFHWPaySDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaQueryProductCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaQueryUncompleteOrderCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFHWPaySDKManager gen_to_be_invoked = (BF.BFHWPaySDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaQueryUncompleteOrderCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaConsumeCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFHWPaySDKManager gen_to_be_invoked = (BF.BFHWPaySDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaConsumeCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_luaPayCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFHWPaySDKManager gen_to_be_invoked = (BF.BFHWPaySDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaPayCallback = translator.GetDelegate>(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_luaQueryProductCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFHWPaySDKManager gen_to_be_invoked = (BF.BFHWPaySDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaQueryProductCallback = translator.GetDelegate>(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_luaQueryUncompleteOrderCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFHWPaySDKManager gen_to_be_invoked = (BF.BFHWPaySDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaQueryUncompleteOrderCallback = translator.GetDelegate>(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_luaConsumeCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFHWPaySDKManager gen_to_be_invoked = (BF.BFHWPaySDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaConsumeCallback = translator.GetDelegate>(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_BFHorizontalOrVerticalLayoutWrap.cs b/Assets/XLua/Gen/BF_BFHorizontalOrVerticalLayoutWrap.cs new file mode 100644 index 000000000..dfda7ae95 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFHorizontalOrVerticalLayoutWrap.cs @@ -0,0 +1,260 @@ +#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 BFBFHorizontalOrVerticalLayoutWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFHorizontalOrVerticalLayout); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 2, 2); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Update", _m_Update); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshLayout", _m_RefreshLayout); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetVerticalSize", _m_GetVerticalSize); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHorizontalSize", _m_GetHorizontalSize); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Spaceing", _g_get_Spaceing); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "VerticalOrHorizontal", _g_get_VerticalOrHorizontal); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Spaceing", _s_set_Spaceing); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "VerticalOrHorizontal", _s_set_VerticalOrHorizontal); + + + 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.BFHorizontalOrVerticalLayout(); + 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.BFHorizontalOrVerticalLayout constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Update(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFHorizontalOrVerticalLayout gen_to_be_invoked = (BF.BFHorizontalOrVerticalLayout)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Update( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RefreshLayout(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFHorizontalOrVerticalLayout gen_to_be_invoked = (BF.BFHorizontalOrVerticalLayout)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RefreshLayout( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetVerticalSize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFHorizontalOrVerticalLayout gen_to_be_invoked = (BF.BFHorizontalOrVerticalLayout)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetVerticalSize( ); + LuaAPI.lua_pushnumber(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_GetHorizontalSize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFHorizontalOrVerticalLayout gen_to_be_invoked = (BF.BFHorizontalOrVerticalLayout)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetHorizontalSize( ); + LuaAPI.lua_pushnumber(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_Spaceing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFHorizontalOrVerticalLayout gen_to_be_invoked = (BF.BFHorizontalOrVerticalLayout)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.Spaceing); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_VerticalOrHorizontal(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFHorizontalOrVerticalLayout gen_to_be_invoked = (BF.BFHorizontalOrVerticalLayout)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.VerticalOrHorizontal); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Spaceing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFHorizontalOrVerticalLayout gen_to_be_invoked = (BF.BFHorizontalOrVerticalLayout)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Spaceing = (float)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_VerticalOrHorizontal(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFHorizontalOrVerticalLayout gen_to_be_invoked = (BF.BFHorizontalOrVerticalLayout)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.VerticalOrHorizontal = LuaAPI.lua_toboolean(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_BFHttpsInfoWrap.cs b/Assets/XLua/Gen/BF_BFHttpsInfoWrap.cs new file mode 100644 index 000000000..f2e7a551d --- /dev/null +++ b/Assets/XLua/Gen/BF_BFHttpsInfoWrap.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 BFBFHttpsInfoWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFHttpsInfo); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 2); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mainDomain", _g_get_mainDomain); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mainPort", _g_get_mainPort); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "mainDomain", _s_set_mainDomain); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "mainPort", _s_set_mainPort); + + + 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) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + string _mainDomain = LuaAPI.lua_tostring(L, 2); + int _mainPort = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = new BF.BFHttpsInfo(_mainDomain, _mainPort); + 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.BFHttpsInfo constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mainDomain(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFHttpsInfo gen_to_be_invoked = (BF.BFHttpsInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.mainDomain); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mainPort(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFHttpsInfo gen_to_be_invoked = (BF.BFHttpsInfo)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.mainPort); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_mainDomain(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFHttpsInfo gen_to_be_invoked = (BF.BFHttpsInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.mainDomain = 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_mainPort(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFHttpsInfo gen_to_be_invoked = (BF.BFHttpsInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.mainPort = 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_BFLanguageInfoWrap.cs b/Assets/XLua/Gen/BF_BFLanguageInfoWrap.cs new file mode 100644 index 000000000..c5866f8d9 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFLanguageInfoWrap.cs @@ -0,0 +1,159 @@ +#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 BFBFLanguageInfoWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFLanguageInfo); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 1, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetFallbackLanguage", _m_GetFallbackLanguage); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Contains", _m_Contains); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Languages", _g_get_Languages); + + + + 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) == 2 && translator.Assignable>(L, 2)) + { + System.Collections.Generic.List _languages = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + var gen_ret = new BF.BFLanguageInfo(_languages); + 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.BFLanguageInfo constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetFallbackLanguage(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLanguageInfo gen_to_be_invoked = (BF.BFLanguageInfo)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetFallbackLanguage( ); + 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 _m_Contains(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLanguageInfo gen_to_be_invoked = (BF.BFLanguageInfo)translator.FastGetCSObj(L, 1); + + + + { + string _lang = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.Contains( _lang ); + 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 _g_get_Languages(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLanguageInfo gen_to_be_invoked = (BF.BFLanguageInfo)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Languages); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_BFLayoutBaseWrap.cs b/Assets/XLua/Gen/BF_BFLayoutBaseWrap.cs new file mode 100644 index 000000000..11599888c --- /dev/null +++ b/Assets/XLua/Gen/BF_BFLayoutBaseWrap.cs @@ -0,0 +1,223 @@ +#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 BFBFLayoutBaseWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFLayoutBase); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 5, 5); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Left", _g_get_Left); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Right", _g_get_Right); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Top", _g_get_Top); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Bottom", _g_get_Bottom); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ChildAlignment", _g_get_ChildAlignment); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Left", _s_set_Left); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Right", _s_set_Right); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Top", _s_set_Top); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Bottom", _s_set_Bottom); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ChildAlignment", _s_set_ChildAlignment); + + + 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, "BF.BFLayoutBase does not have a constructor!"); + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Left(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLayoutBase gen_to_be_invoked = (BF.BFLayoutBase)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.Left); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Right(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLayoutBase gen_to_be_invoked = (BF.BFLayoutBase)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.Right); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Top(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLayoutBase gen_to_be_invoked = (BF.BFLayoutBase)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.Top); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Bottom(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLayoutBase gen_to_be_invoked = (BF.BFLayoutBase)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.Bottom); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ChildAlignment(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLayoutBase gen_to_be_invoked = (BF.BFLayoutBase)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineTextAnchor(L, gen_to_be_invoked.ChildAlignment); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Left(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLayoutBase gen_to_be_invoked = (BF.BFLayoutBase)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Left = (float)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_Right(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLayoutBase gen_to_be_invoked = (BF.BFLayoutBase)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Right = (float)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_Top(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLayoutBase gen_to_be_invoked = (BF.BFLayoutBase)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Top = (float)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_Bottom(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLayoutBase gen_to_be_invoked = (BF.BFLayoutBase)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Bottom = (float)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_ChildAlignment(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLayoutBase gen_to_be_invoked = (BF.BFLayoutBase)translator.FastGetCSObj(L, 1); + UnityEngine.TextAnchor gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.ChildAlignment = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_BFLogWrap.cs b/Assets/XLua/Gen/BF_BFLogWrap.cs new file mode 100644 index 000000000..69a57b735 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFLogWrap.cs @@ -0,0 +1,281 @@ +#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 BFBFLogWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFLog); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 6, 2, 2); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LogDebug", _m_LogDebug_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Log", _m_Log_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LogWarning", _m_LogWarning_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LogError", _m_LogError_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LogAssert", _m_LogAssert_xlua_st_); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "DEBUG_RESMGR", _g_get_DEBUG_RESMGR); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "DEBUG_GAME_LAUNCH", _g_get_DEBUG_GAME_LAUNCH); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "DEBUG_RESMGR", _s_set_DEBUG_RESMGR); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "DEBUG_GAME_LAUNCH", _s_set_DEBUG_GAME_LAUNCH); + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "BF.BFLog does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LogDebug_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count >= 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 3) || translator.Assignable(L, 3))) + { + string _color = LuaAPI.lua_tostring(L, 1); + string _text = LuaAPI.lua_tostring(L, 2); + object[] _par = translator.GetParams(L, 3); + + BF.BFLog.LogDebug( _color, _text, _par ); + + + + return 0; + } + if(gen_param_count >= 3&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)&& (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)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 4) || translator.Assignable(L, 4))) + { + bool _condition = LuaAPI.lua_toboolean(L, 1); + string _color = LuaAPI.lua_tostring(L, 2); + string _text = LuaAPI.lua_tostring(L, 3); + object[] _par = translator.GetParams(L, 4); + + BF.BFLog.LogDebug( _condition, _color, _text, _par ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.BFLog.LogDebug!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Log_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _text = LuaAPI.lua_tostring(L, 1); + object[] _par = translator.GetParams(L, 2); + + BF.BFLog.Log( _text, _par ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LogWarning_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _text = LuaAPI.lua_tostring(L, 1); + object[] _par = translator.GetParams(L, 2); + + BF.BFLog.LogWarning( _text, _par ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LogError_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _text = LuaAPI.lua_tostring(L, 1); + object[] _par = translator.GetParams(L, 2); + + BF.BFLog.LogError( _text, _par ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LogAssert_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + bool _val = LuaAPI.lua_toboolean(L, 1); + string _text = LuaAPI.lua_tostring(L, 2); + object[] _par = translator.GetParams(L, 3); + + var gen_ret = BF.BFLog.LogAssert( _val, _text, _par ); + 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 _g_get_DEBUG_RESMGR(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, BF.BFLog.DEBUG_RESMGR); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DEBUG_GAME_LAUNCH(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, BF.BFLog.DEBUG_GAME_LAUNCH); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_DEBUG_RESMGR(RealStatePtr L) + { + try { + + BF.BFLog.DEBUG_RESMGR = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_DEBUG_GAME_LAUNCH(RealStatePtr L) + { + try { + + BF.BFLog.DEBUG_GAME_LAUNCH = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_BFLoginInfoWrap.cs b/Assets/XLua/Gen/BF_BFLoginInfoWrap.cs new file mode 100644 index 000000000..24cdc5ab6 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFLoginInfoWrap.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 BFBFLoginInfoWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFLoginInfo); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 2); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "loginType", _g_get_loginType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "msg", _g_get_msg); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "loginType", _s_set_loginType); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "msg", _s_set_msg); + + + 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 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + int _loginType = LuaAPI.xlua_tointeger(L, 2); + string _msg = LuaAPI.lua_tostring(L, 3); + + var gen_ret = new BF.BFLoginInfo(_loginType, _msg); + 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.BFLoginInfo constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_loginType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLoginInfo gen_to_be_invoked = (BF.BFLoginInfo)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.loginType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_msg(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLoginInfo gen_to_be_invoked = (BF.BFLoginInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.msg); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_loginType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLoginInfo gen_to_be_invoked = (BF.BFLoginInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.loginType = 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_msg(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLoginInfo gen_to_be_invoked = (BF.BFLoginInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.msg = 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/BF_BFLoginSDKManagerWrap.cs b/Assets/XLua/Gen/BF_BFLoginSDKManagerWrap.cs new file mode 100644 index 000000000..aa88ca715 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFLoginSDKManagerWrap.cs @@ -0,0 +1,1386 @@ +#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 BFBFLoginSDKManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFLoginSDKManager); + Utils.BeginObjectRegister(type, L, translator, 0, 32, 12, 11); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InitListener", _m_InitListener); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLuaLoginCallback", _m_SetLuaLoginCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLuaLogoutCallback", _m_SetLuaLogoutCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLuaBindCallback", _m_SetLuaBindCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLuaServerListCallback", _m_SetLuaServerListCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLuaAccountLoginCallback", _m_SetLuaAccountLoginCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLuaAccountChangeCallback", _m_SetLuaAccountChangeCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNewPlayerGuid", _m_GetNewPlayerGuid); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Login", _m_Login); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Logout", _m_Logout); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetBFToken", _m_GetBFToken); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetBFTokenToBytes", _m_GetBFTokenToBytes); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAccountInfo", _m_SetAccountInfo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAccountInfoBind", _m_SetAccountInfoBind); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAccountInfo", _m_GetAccountInfo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GoogleLoginComplete", _m_GoogleLoginComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GoogleLogoutComplete", _m_GoogleLogoutComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoginComplete", _m_LoginComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LogoutComplete", _m_LogoutComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "BindComplete", _m_BindComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PostWithURL", _m_PostWithURL); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetWithURL", _m_GetWithURL); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetServerList", _m_GetServerList); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "StartAccountChange", _m_StartAccountChange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "StartAccountBind", _m_StartAccountBind); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "StartAccountLogin", _m_StartAccountLogin); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnStartAccountLogin", _m_OnStartAccountLogin); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnStartAccountChange", _m_OnStartAccountChange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetFirebaseToken", _m_SetFirebaseToken); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetFirebaseToken", _m_GetFirebaseToken); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "VKIDLoginComplete", _m_VKIDLoginComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "VKIDLogoutComplete", _m_VKIDLogoutComplete); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "SDKLogin", _g_get_SDKLogin); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AccountLoginSeq", _g_get_AccountLoginSeq); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaLoginCallback", _g_get_luaLoginCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaLogoutCallback", _g_get_luaLogoutCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaBindCallback", _g_get_luaBindCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaServerListCallback", _g_get_luaServerListCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaAccountLoginCallback", _g_get_luaAccountLoginCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaAccountChangeCallback", _g_get_luaAccountChangeCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "FBSdk", _g_get_FBSdk); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "accountInfo", _g_get_accountInfo); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "firebaseToken", _g_get_firebaseToken); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaFirebaseTokenCallback", _g_get_luaFirebaseTokenCallback); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "AccountLoginSeq", _s_set_AccountLoginSeq); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaLoginCallback", _s_set_luaLoginCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaLogoutCallback", _s_set_luaLogoutCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaBindCallback", _s_set_luaBindCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaServerListCallback", _s_set_luaServerListCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaAccountLoginCallback", _s_set_luaAccountLoginCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaAccountChangeCallback", _s_set_luaAccountChangeCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "FBSdk", _s_set_FBSdk); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "accountInfo", _s_set_accountInfo); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "firebaseToken", _s_set_firebaseToken); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaFirebaseTokenCallback", _s_set_luaFirebaseTokenCallback); + + + 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.BFLoginSDKManager(); + 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.BFLoginSDKManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_InitListener(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.InitListener( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLuaLoginCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetLuaLoginCallback( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLuaLogoutCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetLuaLogoutCallback( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLuaBindCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetLuaBindCallback( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLuaServerListCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetLuaServerListCallback( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLuaAccountLoginCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetLuaAccountLoginCallback( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLuaAccountChangeCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetLuaAccountChangeCallback( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetNewPlayerGuid(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetNewPlayerGuid( ); + 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 _m_Login(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + BF.NativeCore.LoginType _type;translator.Get(L, 2, out _type); + + gen_to_be_invoked.Login( _type ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Logout(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + BF.NativeCore.LoginType _type;translator.Get(L, 2, out _type); + + gen_to_be_invoked.Logout( _type ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetBFToken(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetBFToken( ); + 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 _m_GetBFTokenToBytes(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetBFTokenToBytes( ); + 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 _m_SetAccountInfo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _json = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SetAccountInfo( _json ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAccountInfoBind(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _json = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SetAccountInfoBind( _json ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetAccountInfo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _json = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetAccountInfo( _json ); + 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_GoogleLoginComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + bool _succ = LuaAPI.lua_toboolean(L, 2); + string _msg = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.GoogleLoginComplete( _succ, _msg ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GoogleLogoutComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + bool _succ = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.GoogleLogoutComplete( _succ ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoginComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + BF.NativeCore.LoginType _loginType;translator.Get(L, 2, out _loginType); + BF.NativeCore.ULoginResult _result;translator.Get(L, 3, out _result); + string _msg = LuaAPI.lua_tostring(L, 4); + + gen_to_be_invoked.LoginComplete( _loginType, _result, _msg ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LogoutComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + BF.NativeCore.LoginType _loginType;translator.Get(L, 2, out _loginType); + BF.NativeCore.ULoginResult _result;translator.Get(L, 3, out _result); + string _msg = LuaAPI.lua_tostring(L, 4); + + gen_to_be_invoked.LogoutComplete( _loginType, _result, _msg ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_BindComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + BF.NativeCore.ULoginResult _result;translator.Get(L, 2, out _result); + string _msg = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.BindComplete( _result, _msg ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PostWithURL(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _url = LuaAPI.lua_tostring(L, 2); + string _data = LuaAPI.lua_tostring(L, 3); + System.Action _callback = translator.GetDelegate>(L, 4); + + gen_to_be_invoked.PostWithURL( _url, _data, _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetWithURL(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _url = LuaAPI.lua_tostring(L, 2); + System.Action _callback = translator.GetDelegate>(L, 3); + + gen_to_be_invoked.GetWithURL( _url, _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetServerList(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _requestUrl = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.GetServerList( _requestUrl ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_StartAccountChange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _url = LuaAPI.lua_tostring(L, 2); + string _requestArgsJson = LuaAPI.lua_tostring(L, 3); + int _sdkLoginType = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.StartAccountChange( _url, _requestArgsJson, _sdkLoginType ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_StartAccountBind(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + int _sdkLoginType = LuaAPI.xlua_tointeger(L, 2); + string _url = LuaAPI.lua_tostring(L, 3); + string _requestArgsJson = LuaAPI.lua_tostring(L, 4); + System.Action _luaBindCallback = translator.GetDelegate>(L, 5); + + gen_to_be_invoked.StartAccountBind( _sdkLoginType, _url, _requestArgsJson, _luaBindCallback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_StartAccountLogin(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _url = LuaAPI.lua_tostring(L, 2); + string _requestArgsJson = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.StartAccountLogin( _url, _requestArgsJson ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnStartAccountLogin(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _url = LuaAPI.lua_tostring(L, 2); + string _requestArgsJson = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.OnStartAccountLogin( _url, _requestArgsJson ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnStartAccountChange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _url = LuaAPI.lua_tostring(L, 2); + string _requestArgsJson = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.OnStartAccountChange( _url, _requestArgsJson ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetFirebaseToken(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _token = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SetFirebaseToken( _token ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetFirebaseToken(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.GetFirebaseToken( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_VKIDLoginComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + bool _succ = LuaAPI.lua_toboolean(L, 2); + string _msg = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.VKIDLoginComplete( _succ, _msg ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_VKIDLogoutComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + + + + { + bool _succ = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.VKIDLogoutComplete( _succ ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_SDKLogin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.SDKLogin); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AccountLoginSeq(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.AccountLoginSeq); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaLoginCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaLoginCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaLogoutCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaLogoutCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaBindCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaBindCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaServerListCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaServerListCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaAccountLoginCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaAccountLoginCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaAccountChangeCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaAccountChangeCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_FBSdk(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.FBSdk); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_accountInfo(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.accountInfo); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_firebaseToken(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.firebaseToken); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaFirebaseTokenCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaFirebaseTokenCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_AccountLoginSeq(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.AccountLoginSeq = 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_luaLoginCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaLoginCallback = translator.GetDelegate>(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_luaLogoutCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaLogoutCallback = translator.GetDelegate>(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_luaBindCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaBindCallback = translator.GetDelegate>(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_luaServerListCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaServerListCallback = translator.GetDelegate>(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_luaAccountLoginCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaAccountLoginCallback = translator.GetDelegate>(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_luaAccountChangeCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaAccountChangeCallback = translator.GetDelegate>(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_FBSdk(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.FBSdk = (BF.NativeCore.ThirdPlatform.FacebookSdk)translator.GetObject(L, 2, typeof(BF.NativeCore.ThirdPlatform.FacebookSdk)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_accountInfo(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.accountInfo = (BF.BFAccountInfo)translator.GetObject(L, 2, typeof(BF.BFAccountInfo)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_firebaseToken(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.firebaseToken = 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_luaFirebaseTokenCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFLoginSDKManager gen_to_be_invoked = (BF.BFLoginSDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaFirebaseTokenCallback = translator.GetDelegate>(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_BFMainWrap.cs b/Assets/XLua/Gen/BF_BFMainWrap.cs new file mode 100644 index 000000000..2672db48f --- /dev/null +++ b/Assets/XLua/Gen/BF_BFMainWrap.cs @@ -0,0 +1,824 @@ +#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 BFBFMainWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFMain); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 16, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "StartGame", _m_StartGame); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Destroy", _m_Destroy); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "GameLaunchMgr", _g_get_GameLaunchMgr); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "LuaMgr", _g_get_LuaMgr); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "LoomMgr", _g_get_LoomMgr); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PoolMgr", _g_get_PoolMgr); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "TouchMgr", _g_get_TouchMgr); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "RenderMgr", _g_get_RenderMgr); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ResMgr", _g_get_ResMgr); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "NetMgr", _g_get_NetMgr); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "WebRequestMgr", _g_get_WebRequestMgr); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "OneShotManager", _g_get_OneShotManager); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "SoundManager", _g_get_SoundManager); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "TaskMgr", _g_get_TaskMgr); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "BIReport", _g_get_BIReport); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "SDKMgr", _g_get_SDKMgr); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ParseClientMgr", _g_get_ParseClientMgr); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "URPMgr", _g_get_URPMgr); + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 6, 16, 13); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetServerTime", _m_SetServerTime_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ForFree", _m_ForFree_xlua_st_); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CLIENT_VERSION", BF.BFMain.CLIENT_VERSION); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FILE_HEAD", BF.BFMain.FILE_HEAD); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FILE_HEAD_BASE64", BF.BFMain.FILE_HEAD_BASE64); + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "ProjectId", _g_get_ProjectId); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "ProjectEnv", _g_get_ProjectEnv); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "ForceEnv", _g_get_ForceEnv); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "IsStandAlone", _g_get_IsStandAlone); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "IsShenhe", _g_get_IsShenhe); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "IsWhite", _g_get_IsWhite); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "IsGotServerTime", _g_get_IsGotServerTime); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "ServerTime", _g_get_ServerTime); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "DifferenceTime", _g_get_DifferenceTime); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "DPEntrance", _g_get_DPEntrance); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "DPIsLan", _g_get_DPIsLan); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "DPEnv", _g_get_DPEnv); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "DPSupportGM", _g_get_DPSupportGM); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "DPSupportLog", _g_get_DPSupportLog); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "DPPackageName", _g_get_DPPackageName); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "DPForceEnv", _g_get_DPForceEnv); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "IsStandAlone", _s_set_IsStandAlone); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "IsShenhe", _s_set_IsShenhe); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "IsWhite", _s_set_IsWhite); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "IsGotServerTime", _s_set_IsGotServerTime); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "ServerTime", _s_set_ServerTime); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "DifferenceTime", _s_set_DifferenceTime); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "DPEntrance", _s_set_DPEntrance); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "DPIsLan", _s_set_DPIsLan); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "DPEnv", _s_set_DPEnv); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "DPSupportGM", _s_set_DPSupportGM); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "DPSupportLog", _s_set_DPSupportLog); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "DPPackageName", _s_set_DPPackageName); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "DPForceEnv", _s_set_DPForceEnv); + + + 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.BFMain(); + 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.BFMain constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_StartGame(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFMain gen_to_be_invoked = (BF.BFMain)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.StartGame( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Destroy(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFMain gen_to_be_invoked = (BF.BFMain)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Destroy( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetServerTime_xlua_st_(RealStatePtr L) + { + try { + + + + + { + long _serverTime = LuaAPI.lua_toint64(L, 1); + + BF.BFMain.SetServerTime( _serverTime ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ForFree_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _str = LuaAPI.lua_tostring(L, 1); + + var gen_ret = BF.BFMain.ForFree( _str ); + 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_ProjectId(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, BF.BFMain.ProjectId); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ProjectEnv(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, BF.BFMain.ProjectEnv); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ForceEnv(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, BF.BFMain.ForceEnv); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_GameLaunchMgr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFMain gen_to_be_invoked = (BF.BFMain)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.GameLaunchMgr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_LuaMgr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFMain gen_to_be_invoked = (BF.BFMain)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.LuaMgr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_LoomMgr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFMain gen_to_be_invoked = (BF.BFMain)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.LoomMgr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PoolMgr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFMain gen_to_be_invoked = (BF.BFMain)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.PoolMgr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_TouchMgr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFMain gen_to_be_invoked = (BF.BFMain)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.TouchMgr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_RenderMgr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFMain gen_to_be_invoked = (BF.BFMain)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.RenderMgr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ResMgr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFMain gen_to_be_invoked = (BF.BFMain)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.ResMgr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_NetMgr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFMain gen_to_be_invoked = (BF.BFMain)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.NetMgr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_WebRequestMgr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFMain gen_to_be_invoked = (BF.BFMain)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.WebRequestMgr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_OneShotManager(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFMain gen_to_be_invoked = (BF.BFMain)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.OneShotManager); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_SoundManager(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFMain gen_to_be_invoked = (BF.BFMain)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.SoundManager); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_TaskMgr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFMain gen_to_be_invoked = (BF.BFMain)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.TaskMgr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_BIReport(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFMain gen_to_be_invoked = (BF.BFMain)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.BIReport); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_SDKMgr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFMain gen_to_be_invoked = (BF.BFMain)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.SDKMgr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ParseClientMgr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFMain gen_to_be_invoked = (BF.BFMain)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.ParseClientMgr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_URPMgr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFMain gen_to_be_invoked = (BF.BFMain)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.URPMgr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsStandAlone(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, BF.BFMain.IsStandAlone); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsShenhe(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, BF.BFMain.IsShenhe); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsWhite(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, BF.BFMain.IsWhite); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsGotServerTime(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, BF.BFMain.IsGotServerTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ServerTime(RealStatePtr L) + { + try { + + LuaAPI.lua_pushint64(L, BF.BFMain.ServerTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DifferenceTime(RealStatePtr L) + { + try { + + LuaAPI.lua_pushint64(L, BF.BFMain.DifferenceTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DPEntrance(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, BF.BFMain.DPEntrance); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DPIsLan(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, BF.BFMain.DPIsLan); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DPEnv(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, BF.BFMain.DPEnv); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DPSupportGM(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, BF.BFMain.DPSupportGM); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DPSupportLog(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, BF.BFMain.DPSupportLog); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DPPackageName(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, BF.BFMain.DPPackageName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DPForceEnv(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, BF.BFMain.DPForceEnv); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_IsStandAlone(RealStatePtr L) + { + try { + + BF.BFMain.IsStandAlone = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_IsShenhe(RealStatePtr L) + { + try { + + BF.BFMain.IsShenhe = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_IsWhite(RealStatePtr L) + { + try { + + BF.BFMain.IsWhite = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_IsGotServerTime(RealStatePtr L) + { + try { + + BF.BFMain.IsGotServerTime = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_ServerTime(RealStatePtr L) + { + try { + + BF.BFMain.ServerTime = LuaAPI.lua_toint64(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_DifferenceTime(RealStatePtr L) + { + try { + + BF.BFMain.DifferenceTime = LuaAPI.lua_toint64(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_DPEntrance(RealStatePtr L) + { + try { + + BF.BFMain.DPEntrance = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_DPIsLan(RealStatePtr L) + { + try { + + BF.BFMain.DPIsLan = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_DPEnv(RealStatePtr L) + { + try { + + BF.BFMain.DPEnv = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_DPSupportGM(RealStatePtr L) + { + try { + + BF.BFMain.DPSupportGM = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_DPSupportLog(RealStatePtr L) + { + try { + + BF.BFMain.DPSupportLog = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_DPPackageName(RealStatePtr L) + { + try { + + BF.BFMain.DPPackageName = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_DPForceEnv(RealStatePtr L) + { + try { + + BF.BFMain.DPForceEnv = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_BFNativeSDKManagerWrap.cs b/Assets/XLua/Gen/BF_BFNativeSDKManagerWrap.cs new file mode 100644 index 000000000..da5852e3c --- /dev/null +++ b/Assets/XLua/Gen/BF_BFNativeSDKManagerWrap.cs @@ -0,0 +1,1535 @@ +#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 BFBFNativeSDKManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFNativeSDKManager); + Utils.BeginObjectRegister(type, L, translator, 0, 50, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InitGoogleLogin", _m_InitGoogleLogin); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InitGooglePay", _m_InitGooglePay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InitAdmobRewardedVideo", _m_InitAdmobRewardedVideo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InitGDPR", _m_InitGDPR); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GooglePay", _m_GooglePay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ConsumePurchase", _m_ConsumePurchase); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GoogleLogin", _m_GoogleLogin); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GoogleLogout", _m_GoogleLogout); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "QueryGoogleProductInfo", _m_QueryGoogleProductInfo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ConnectGoogleStore", _m_ConnectGoogleStore); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "QueryUncompleteOrder", _m_QueryUncompleteOrder); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "QuerySubscribeInfo", _m_QuerySubscribeInfo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetFirebaseToken", _m_GetFirebaseToken); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ShowFullScreenAds", _m_ShowFullScreenAds); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryLoadRewardedAd", _m_TryLoadRewardedAd); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAdPlacement", _m_SetAdPlacement); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LogEvent", _m_LogEvent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LogCrashCustomKey", _m_LogCrashCustomKey); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsPrivacyOptionsRequired", _m_IsPrivacyOptionsRequired); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ShowPrivacyOptionsForm", _m_ShowPrivacyOptionsForm); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetGDPR", _m_ResetGDPR); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnUMPFinish", _m_OnUMPFinish); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAppSignMD5", _m_GetAppSignMD5); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAppSignSHA1", _m_GetAppSignSHA1); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAppSignSHA256", _m_GetAppSignSHA256); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RequestStoreReview", _m_RequestStoreReview); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RuInit", _m_RuInit); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RuCheckValid", _m_RuCheckValid); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RuGetProducts", _m_RuGetProducts); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RuGetPurchase", _m_RuGetPurchase); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RuPurchase", _m_RuPurchase); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RuConsume", _m_RuConsume); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RuDelete", _m_RuDelete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsAndroidPkgInstalled", _m_IsAndroidPkgInstalled); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RuRequestStoreReview", _m_RuRequestStoreReview); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "VKIDInit", _m_VKIDInit); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "VKIDLogout", _m_VKIDLogout); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "VKIDLogin", _m_VKIDLogin); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IOSVKLoginCallBack", _m_IOSVKLoginCallBack); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PayDukPay", _m_PayDukPay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HWCheckValid", _m_HWCheckValid); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HWGetProducts", _m_HWGetProducts); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HWGetPurchase", _m_HWGetPurchase); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HWPurchase", _m_HWPurchase); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HWConsume", _m_HWConsume); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InitHWAdRewardedVideo", _m_InitHWAdRewardedVideo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ShowHWFullScreenAds", _m_ShowHWFullScreenAds); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryLoadHWRewardedAd", _m_TryLoadHWRewardedAd); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OpenUrl", _m_OpenUrl); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "MsgFromAndroidOrIOS", _m_MsgFromAndroidOrIOS); + + + + + + 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.BFNativeSDKManager(); + 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.BFNativeSDKManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_InitGoogleLogin(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.InitGoogleLogin( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_InitGooglePay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.InitGooglePay( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_InitAdmobRewardedVideo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.InitAdmobRewardedVideo( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_InitGDPR(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.InitGDPR( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GooglePay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _payType = LuaAPI.lua_tostring(L, 2); + string _productId = LuaAPI.lua_tostring(L, 3); + string _customMsg = LuaAPI.lua_tostring(L, 4); + + gen_to_be_invoked.GooglePay( _payType, _productId, _customMsg ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ConsumePurchase(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _token = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.ConsumePurchase( _token ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GoogleLogin(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.GoogleLogin( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GoogleLogout(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.GoogleLogout( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_QueryGoogleProductInfo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _payType = LuaAPI.lua_tostring(L, 2); + string _productJson = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.QueryGoogleProductInfo( _payType, _productJson ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ConnectGoogleStore(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ConnectGoogleStore( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_QueryUncompleteOrder(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _payType = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.QueryUncompleteOrder( _payType ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_QuerySubscribeInfo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _payType = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.QuerySubscribeInfo( _payType ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetFirebaseToken(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.GetFirebaseToken( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ShowFullScreenAds(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ShowFullScreenAds( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TryLoadRewardedAd(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.TryLoadRewardedAd( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAdPlacement(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _placement = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SetAdPlacement( _placement ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LogEvent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 3)) + { + string _eventName = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.Dictionary _eventValues = (System.Collections.Generic.Dictionary)translator.GetObject(L, 3, typeof(System.Collections.Generic.Dictionary)); + + gen_to_be_invoked.LogEvent( _eventName, _eventValues ); + + + + return 0; + } + if(gen_param_count == 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 _eventName = LuaAPI.lua_tostring(L, 2); + string _eventValues = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.LogEvent( _eventName, _eventValues ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.BFNativeSDKManager.LogEvent!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LogCrashCustomKey(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _key = LuaAPI.lua_tostring(L, 2); + string _stack = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.LogCrashCustomKey( _key, _stack ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsPrivacyOptionsRequired(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsPrivacyOptionsRequired( ); + 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_ShowPrivacyOptionsForm(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ShowPrivacyOptionsForm( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetGDPR(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ResetGDPR( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnUMPFinish(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _stateStr = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.OnUMPFinish( _stateStr ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetAppSignMD5(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetAppSignMD5( ); + 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 _m_GetAppSignSHA1(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetAppSignSHA1( ); + 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 _m_GetAppSignSHA256(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetAppSignSHA256( ); + 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 _m_RequestStoreReview(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RequestStoreReview( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RuInit(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RuInit( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RuCheckValid(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RuCheckValid( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RuGetProducts(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _productJson = LuaAPI.lua_tostring(L, 2); + System.Action _callback = translator.GetDelegate>(L, 3); + + gen_to_be_invoked.RuGetProducts( _productJson, _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RuGetPurchase(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RuGetPurchase( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RuPurchase(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _productId = LuaAPI.lua_tostring(L, 2); + string _customMsg = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.RuPurchase( _productId, _customMsg ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RuConsume(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _purchaseId = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.RuConsume( _purchaseId ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RuDelete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _purchaseId = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.RuDelete( _purchaseId ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsAndroidPkgInstalled(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _pkgName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.IsAndroidPkgInstalled( _pkgName ); + 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_RuRequestStoreReview(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RuRequestStoreReview( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_VKIDInit(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _id = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.VKIDInit( _id ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_VKIDLogout(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.VKIDLogout( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_VKIDLogin(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.VKIDLogin( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IOSVKLoginCallBack(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _code = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.IOSVKLoginCallBack( _code ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PayDukPay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _url = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.PayDukPay( _url ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HWCheckValid(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.HWCheckValid( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HWGetProducts(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _productJson = LuaAPI.lua_tostring(L, 2); + System.Action _callback = translator.GetDelegate>(L, 3); + + gen_to_be_invoked.HWGetProducts( _productJson, _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HWGetPurchase(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.HWGetPurchase( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HWPurchase(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _productId = LuaAPI.lua_tostring(L, 2); + string _customMsg = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.HWPurchase( _productId, _customMsg ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HWConsume(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _productJson = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.HWConsume( _productJson ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_InitHWAdRewardedVideo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.InitHWAdRewardedVideo( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ShowHWFullScreenAds(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ShowHWFullScreenAds( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TryLoadHWRewardedAd(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.TryLoadHWRewardedAd( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OpenUrl(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _url = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.OpenUrl( _url ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_MsgFromAndroidOrIOS(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFNativeSDKManager gen_to_be_invoked = (BF.BFNativeSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _content = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.MsgFromAndroidOrIOS( _content ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_BFNativeSDKManager_NativeResultMsgWrap.cs b/Assets/XLua/Gen/BF_BFNativeSDKManager_NativeResultMsgWrap.cs new file mode 100644 index 000000000..6d98481d5 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFNativeSDKManager_NativeResultMsgWrap.cs @@ -0,0 +1,146 @@ +#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 BFBFNativeSDKManagerNativeResultMsgWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFNativeSDKManager.NativeResultMsg); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 2); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "head", _g_get_head); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "body", _g_get_body); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "head", _s_set_head); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "body", _s_set_body); + + + 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.BFNativeSDKManager.NativeResultMsg(); + 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.BFNativeSDKManager.NativeResultMsg constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_head(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFNativeSDKManager.NativeResultMsg gen_to_be_invoked = (BF.BFNativeSDKManager.NativeResultMsg)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.head); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_body(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFNativeSDKManager.NativeResultMsg gen_to_be_invoked = (BF.BFNativeSDKManager.NativeResultMsg)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.body); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_head(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFNativeSDKManager.NativeResultMsg gen_to_be_invoked = (BF.BFNativeSDKManager.NativeResultMsg)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.head = 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_body(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFNativeSDKManager.NativeResultMsg gen_to_be_invoked = (BF.BFNativeSDKManager.NativeResultMsg)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.body = 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/BF_BFNativeSDKMessageWrap.cs b/Assets/XLua/Gen/BF_BFNativeSDKMessageWrap.cs new file mode 100644 index 000000000..a8457e25b --- /dev/null +++ b/Assets/XLua/Gen/BF_BFNativeSDKMessageWrap.cs @@ -0,0 +1,129 @@ +#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 BFBFNativeSDKMessageWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFNativeSDKMessage); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 63, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GOOGLE_LOGIN_SUCCESS", BF.BFNativeSDKMessage.GOOGLE_LOGIN_SUCCESS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GOOGLE_LOGIN_FAILED", BF.BFNativeSDKMessage.GOOGLE_LOGIN_FAILED); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GOOGLE_LOGOUT_SUCCESS", BF.BFNativeSDKMessage.GOOGLE_LOGOUT_SUCCESS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GOOGLE_PAY_SUCCESS", BF.BFNativeSDKMessage.GOOGLE_PAY_SUCCESS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GOOGLE_PAY_FAILED", BF.BFNativeSDKMessage.GOOGLE_PAY_FAILED); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GOOGLE_PAY_CANCEL", BF.BFNativeSDKMessage.GOOGLE_PAY_CANCEL); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GOOGLE_CONNECT_SUCCESS", BF.BFNativeSDKMessage.GOOGLE_CONNECT_SUCCESS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GOOGLE_CONNECT_FAILED", BF.BFNativeSDKMessage.GOOGLE_CONNECT_FAILED); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "QUERY_PRODUCT_SUCCESS", BF.BFNativeSDKMessage.QUERY_PRODUCT_SUCCESS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "QUERY_PRODUCT_FAILED", BF.BFNativeSDKMessage.QUERY_PRODUCT_FAILED); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "QUERY_UNCOMPLETE_ORDER_FINISH", BF.BFNativeSDKMessage.QUERY_UNCOMPLETE_ORDER_FINISH); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GOOGLE_CONSUME_SUCCESS", BF.BFNativeSDKMessage.GOOGLE_CONSUME_SUCCESS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GOOGLE_CONSUME_FAILED", BF.BFNativeSDKMessage.GOOGLE_CONSUME_FAILED); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GOOGLE_LOGOUT_FAILED", BF.BFNativeSDKMessage.GOOGLE_LOGOUT_FAILED); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FIREBASE_TOKEN", BF.BFNativeSDKMessage.FIREBASE_TOKEN); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "QUERY_SUBSCRIBE_FINISH", BF.BFNativeSDKMessage.QUERY_SUBSCRIBE_FINISH); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ADMOB_SHOWED_FULLSCREEN", BF.BFNativeSDKMessage.ADMOB_SHOWED_FULLSCREEN); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ADMOB_FAILEDTO_SHOW_FULLSCREEN", BF.BFNativeSDKMessage.ADMOB_FAILEDTO_SHOW_FULLSCREEN); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ADMOB_DISMISSED_FULLSCREEN", BF.BFNativeSDKMessage.ADMOB_DISMISSED_FULLSCREEN); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ADMOB_LOADED", BF.BFNativeSDKMessage.ADMOB_LOADED); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ADMOB_LOADED_FAILED", BF.BFNativeSDKMessage.ADMOB_LOADED_FAILED); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ADMOB_EARNED_REWARD", BF.BFNativeSDKMessage.ADMOB_EARNED_REWARD); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ADMOB_INITIALIZED", BF.BFNativeSDKMessage.ADMOB_INITIALIZED); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UMP_REQUEST_CONSENT_ERROR", BF.BFNativeSDKMessage.UMP_REQUEST_CONSENT_ERROR); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UMP_LOAD_AND_PRESENT_ERROR", BF.BFNativeSDKMessage.UMP_LOAD_AND_PRESENT_ERROR); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UMP_SUCCESS_CALLBACK", BF.BFNativeSDKMessage.UMP_SUCCESS_CALLBACK); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UMP_PARALLEL_CALLBACK", BF.BFNativeSDKMessage.UMP_PARALLEL_CALLBACK); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RU_CHECK_VALID_SUCCESS", BF.BFNativeSDKMessage.RU_CHECK_VALID_SUCCESS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RU_CHECK_VALID_FAILED", BF.BFNativeSDKMessage.RU_CHECK_VALID_FAILED); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RU_GET_PRODUCTS_SUCCESS", BF.BFNativeSDKMessage.RU_GET_PRODUCTS_SUCCESS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RU_GET_PRODUCTS_FAILED", BF.BFNativeSDKMessage.RU_GET_PRODUCTS_FAILED); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RU_GET_PURCHASE_SUCCESS", BF.BFNativeSDKMessage.RU_GET_PURCHASE_SUCCESS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RU_GET_PURCHASE_FAILED", BF.BFNativeSDKMessage.RU_GET_PURCHASE_FAILED); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RU_PURCHASE_SUCCESS", BF.BFNativeSDKMessage.RU_PURCHASE_SUCCESS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RU_PURCHASE_FAILED", BF.BFNativeSDKMessage.RU_PURCHASE_FAILED); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RU_PURCHASE_CANCEL", BF.BFNativeSDKMessage.RU_PURCHASE_CANCEL); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RU_CONSUME_SUCCESS", BF.BFNativeSDKMessage.RU_CONSUME_SUCCESS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RU_CONSUME_FAILED", BF.BFNativeSDKMessage.RU_CONSUME_FAILED); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RU_STORE_REVIEW_REQUEST_SUCCESS", BF.BFNativeSDKMessage.RU_STORE_REVIEW_REQUEST_SUCCESS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RU_STORE_REVIEW_REQUEST_FAILED", BF.BFNativeSDKMessage.RU_STORE_REVIEW_REQUEST_FAILED); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RU_STORE_REVIEW_LAUNCH_SUCCESS", BF.BFNativeSDKMessage.RU_STORE_REVIEW_LAUNCH_SUCCESS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RU_STORE_REVIEW_LAUNCH_FAILED", BF.BFNativeSDKMessage.RU_STORE_REVIEW_LAUNCH_FAILED); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RU_VKID_LOGIN_SUCCESS", BF.BFNativeSDKMessage.RU_VKID_LOGIN_SUCCESS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RU_VKID_LOGIN_FAILED", BF.BFNativeSDKMessage.RU_VKID_LOGIN_FAILED); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RU_VKID_LOGOUT_SUCCESS", BF.BFNativeSDKMessage.RU_VKID_LOGOUT_SUCCESS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RU_VKID_LOGOUT_FAILED", BF.BFNativeSDKMessage.RU_VKID_LOGOUT_FAILED); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HW_CHECK_VALID_SUCCESS", BF.BFNativeSDKMessage.HW_CHECK_VALID_SUCCESS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HW_CHECK_VALID_FAILED", BF.BFNativeSDKMessage.HW_CHECK_VALID_FAILED); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HW_GET_PRODUCTS_SUCCESS", BF.BFNativeSDKMessage.HW_GET_PRODUCTS_SUCCESS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HW_GET_PRODUCTS_FAILED", BF.BFNativeSDKMessage.HW_GET_PRODUCTS_FAILED); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HW_GET_PURCHASE_SUCCESS", BF.BFNativeSDKMessage.HW_GET_PURCHASE_SUCCESS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HW_GET_PURCHASE_FAILED", BF.BFNativeSDKMessage.HW_GET_PURCHASE_FAILED); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HW_PURCHASE_SUCCESS", BF.BFNativeSDKMessage.HW_PURCHASE_SUCCESS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HW_PURCHASE_FAILED", BF.BFNativeSDKMessage.HW_PURCHASE_FAILED); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HW_PURCHASE_CANCEL", BF.BFNativeSDKMessage.HW_PURCHASE_CANCEL); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HW_CONSUME_SUCCESS", BF.BFNativeSDKMessage.HW_CONSUME_SUCCESS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HW_CONSUME_FAILED", BF.BFNativeSDKMessage.HW_CONSUME_FAILED); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HW_SHOWED_FULLSCREEN", BF.BFNativeSDKMessage.HW_SHOWED_FULLSCREEN); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HW_FAILEDTO_SHOW_FULLSCREEN", BF.BFNativeSDKMessage.HW_FAILEDTO_SHOW_FULLSCREEN); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HW_LOADED", BF.BFNativeSDKMessage.HW_LOADED); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HW_LOADED_FAILED", BF.BFNativeSDKMessage.HW_LOADED_FAILED); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HW_EARNED_REWARD", BF.BFNativeSDKMessage.HW_EARNED_REWARD); + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "BF.BFNativeSDKMessage does not have a constructor!"); + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_BFParseClientManagerWrap.cs b/Assets/XLua/Gen/BF_BFParseClientManagerWrap.cs new file mode 100644 index 000000000..0b2b35b2e --- /dev/null +++ b/Assets/XLua/Gen/BF_BFParseClientManagerWrap.cs @@ -0,0 +1,1160 @@ +#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 BFBFParseClientManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFParseClientManager); + Utils.BeginObjectRegister(type, L, translator, 0, 29, 5, 5); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetServerUrl", _m_SetServerUrl); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLuaCheckPurchaseOrderCallback", _m_SetLuaCheckPurchaseOrderCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLuaCheckPurchaseConsumeCallback", _m_SetLuaCheckPurchaseConsumeCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLuaCheckPurchaseIOSOrderCallback", _m_SetLuaCheckPurchaseIOSOrderCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLuaCheckPurchaseIOSConsumeCallback", _m_SetLuaCheckPurchaseIOSConsumeCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLuaFirstRequestCallback", _m_SetLuaFirstRequestCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UserLogin", _m_UserLogin); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UserTokenLogin", _m_UserTokenLogin); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UsersPost", _m_UsersPost); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UsersGet", _m_UsersGet); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UsersPut", _m_UsersPut); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UsersDel", _m_UsersDel); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CheckPurchaseGPOrder", _m_CheckPurchaseGPOrder); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CheckPurchaseGPConsume", _m_CheckPurchaseGPConsume); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FirstRequestAction", _m_FirstRequestAction); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CheckPurchaseIOSOrder", _m_CheckPurchaseIOSOrder); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CheckPurchaseIOSConsume", _m_CheckPurchaseIOSConsume); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnCheckPurchaseGPOrder", _m_OnCheckPurchaseGPOrder); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnCheckPurchaseGPConsume", _m_OnCheckPurchaseGPConsume); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnFirstRequestAction", _m_OnFirstRequestAction); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnCheckPurchaseIOSOrder", _m_OnCheckPurchaseIOSOrder); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnCheckPurchaseIOSConsume", _m_OnCheckPurchaseIOSConsume); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FunctionPost", _m_FunctionPost); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "StorageWrite", _m_StorageWrite); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "StorageRead", _m_StorageRead); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "StorageUpdate", _m_StorageUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "StorageDelete", _m_StorageDelete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Put", _m_Put); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaCheckPurchaseOrderCallback", _g_get_luaCheckPurchaseOrderCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaCheckPurchaseConsumeCallback", _g_get_luaCheckPurchaseConsumeCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaFirstRequestCallback", _g_get_luaFirstRequestCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaCheckPurchaseIOSOrderCallback", _g_get_luaCheckPurchaseIOSOrderCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaCheckPurchaseIOSConsumeCallback", _g_get_luaCheckPurchaseIOSConsumeCallback); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaCheckPurchaseOrderCallback", _s_set_luaCheckPurchaseOrderCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaCheckPurchaseConsumeCallback", _s_set_luaCheckPurchaseConsumeCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaFirstRequestCallback", _s_set_luaFirstRequestCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaCheckPurchaseIOSOrderCallback", _s_set_luaCheckPurchaseIOSOrderCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaCheckPurchaseIOSConsumeCallback", _s_set_luaCheckPurchaseIOSConsumeCallback); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Create", _m_Create_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "BF.BFParseClientManager does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Create_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = BF.BFParseClientManager.Create( ); + 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_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetServerUrl(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 7&& (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)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 5) || LuaAPI.lua_type(L, 5) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 6) || LuaAPI.lua_type(L, 6) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 7) || LuaAPI.lua_type(L, 7) == LuaTypes.LUA_TSTRING)) + { + string _url = LuaAPI.lua_tostring(L, 2); + string _parseClientPlatform = LuaAPI.lua_tostring(L, 3); + string _parseClientVersion = LuaAPI.lua_tostring(L, 4); + string _psarseRevocableSession = LuaAPI.lua_tostring(L, 5); + string _parseApplicationId = LuaAPI.lua_tostring(L, 6); + string _parseClientKey = LuaAPI.lua_tostring(L, 7); + + gen_to_be_invoked.SetServerUrl( _url, _parseClientPlatform, _parseClientVersion, _psarseRevocableSession, _parseApplicationId, _parseClientKey ); + + + + return 0; + } + if(gen_param_count == 6&& (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)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 5) || LuaAPI.lua_type(L, 5) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 6) || LuaAPI.lua_type(L, 6) == LuaTypes.LUA_TSTRING)) + { + string _url = LuaAPI.lua_tostring(L, 2); + string _parseClientPlatform = LuaAPI.lua_tostring(L, 3); + string _parseClientVersion = LuaAPI.lua_tostring(L, 4); + string _psarseRevocableSession = LuaAPI.lua_tostring(L, 5); + string _parseApplicationId = LuaAPI.lua_tostring(L, 6); + + gen_to_be_invoked.SetServerUrl( _url, _parseClientPlatform, _parseClientVersion, _psarseRevocableSession, _parseApplicationId ); + + + + return 0; + } + if(gen_param_count == 5&& (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)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 5) || LuaAPI.lua_type(L, 5) == LuaTypes.LUA_TSTRING)) + { + string _url = LuaAPI.lua_tostring(L, 2); + string _parseClientPlatform = LuaAPI.lua_tostring(L, 3); + string _parseClientVersion = LuaAPI.lua_tostring(L, 4); + string _psarseRevocableSession = LuaAPI.lua_tostring(L, 5); + + gen_to_be_invoked.SetServerUrl( _url, _parseClientPlatform, _parseClientVersion, _psarseRevocableSession ); + + + + return 0; + } + if(gen_param_count == 4&& (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)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)) + { + string _url = LuaAPI.lua_tostring(L, 2); + string _parseClientPlatform = LuaAPI.lua_tostring(L, 3); + string _parseClientVersion = LuaAPI.lua_tostring(L, 4); + + gen_to_be_invoked.SetServerUrl( _url, _parseClientPlatform, _parseClientVersion ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.BFParseClientManager.SetServerUrl!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLuaCheckPurchaseOrderCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetLuaCheckPurchaseOrderCallback( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLuaCheckPurchaseConsumeCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetLuaCheckPurchaseConsumeCallback( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLuaCheckPurchaseIOSOrderCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetLuaCheckPurchaseIOSOrderCallback( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLuaCheckPurchaseIOSConsumeCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetLuaCheckPurchaseIOSConsumeCallback( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLuaFirstRequestCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetLuaFirstRequestCallback( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UserLogin(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + + + + { + string _loginiInfo = LuaAPI.lua_tostring(L, 2); + System.Action _complete = translator.GetDelegate>(L, 3); + + gen_to_be_invoked.UserLogin( _loginiInfo, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UserTokenLogin(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + + + + { + string _token = LuaAPI.lua_tostring(L, 2); + string _loginiInfo = LuaAPI.lua_tostring(L, 3); + System.Action _complete = translator.GetDelegate>(L, 4); + + gen_to_be_invoked.UserTokenLogin( _token, _loginiInfo, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UsersPost(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + + + + { + string _key = LuaAPI.lua_tostring(L, 2); + string _body = LuaAPI.lua_tostring(L, 3); + System.Action _complete = translator.GetDelegate>(L, 4); + + gen_to_be_invoked.UsersPost( _key, _body, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UsersGet(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + + + + { + string _key = LuaAPI.lua_tostring(L, 2); + string _body = LuaAPI.lua_tostring(L, 3); + System.Action _complete = translator.GetDelegate>(L, 4); + + gen_to_be_invoked.UsersGet( _key, _body, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UsersPut(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + + + + { + string _key = LuaAPI.lua_tostring(L, 2); + string _body = LuaAPI.lua_tostring(L, 3); + System.Action _complete = translator.GetDelegate>(L, 4); + + gen_to_be_invoked.UsersPut( _key, _body, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UsersDel(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + + + + { + string _key = LuaAPI.lua_tostring(L, 2); + string _body = LuaAPI.lua_tostring(L, 3); + System.Action _complete = translator.GetDelegate>(L, 4); + + gen_to_be_invoked.UsersDel( _key, _body, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CheckPurchaseGPOrder(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + + + + { + string _purchase = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.CheckPurchaseGPOrder( _purchase ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CheckPurchaseGPConsume(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + + + + { + string _purchase = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.CheckPurchaseGPConsume( _purchase ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FirstRequestAction(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + + + + { + string _info = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.FirstRequestAction( _info ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CheckPurchaseIOSOrder(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + + + + { + string _purchase = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.CheckPurchaseIOSOrder( _purchase ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CheckPurchaseIOSConsume(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + + + + { + string _purchase = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.CheckPurchaseIOSConsume( _purchase ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnCheckPurchaseGPOrder(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + + + + { + string _msg = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.OnCheckPurchaseGPOrder( _msg ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnCheckPurchaseGPConsume(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + + + + { + string _msg = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.OnCheckPurchaseGPConsume( _msg ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnFirstRequestAction(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + + + + { + string _msg = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.OnFirstRequestAction( _msg ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnCheckPurchaseIOSOrder(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + + + + { + string _msg = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.OnCheckPurchaseIOSOrder( _msg ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnCheckPurchaseIOSConsume(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + + + + { + string _msg = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.OnCheckPurchaseIOSConsume( _msg ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FunctionPost(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + + + + { + string _url = LuaAPI.lua_tostring(L, 2); + string _body = LuaAPI.lua_tostring(L, 3); + System.Action _complete = translator.GetDelegate>(L, 4); + + gen_to_be_invoked.FunctionPost( _url, _body, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_StorageWrite(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + + + + { + string _key = LuaAPI.lua_tostring(L, 2); + string _body = LuaAPI.lua_tostring(L, 3); + System.Action _complete = translator.GetDelegate>(L, 4); + + gen_to_be_invoked.StorageWrite( _key, _body, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_StorageRead(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + + + + { + string _key = LuaAPI.lua_tostring(L, 2); + string _body = LuaAPI.lua_tostring(L, 3); + System.Action _complete = translator.GetDelegate>(L, 4); + + gen_to_be_invoked.StorageRead( _key, _body, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_StorageUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + + + + { + string _key = LuaAPI.lua_tostring(L, 2); + string _body = LuaAPI.lua_tostring(L, 3); + System.Action _complete = translator.GetDelegate>(L, 4); + + gen_to_be_invoked.StorageUpdate( _key, _body, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_StorageDelete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + + + + { + string _key = LuaAPI.lua_tostring(L, 2); + string _deleteKeys = LuaAPI.lua_tostring(L, 3); + System.Action _complete = translator.GetDelegate>(L, 4); + + gen_to_be_invoked.StorageDelete( _key, _deleteKeys, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Put(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + + + + { + string _url = LuaAPI.lua_tostring(L, 2); + string _body = LuaAPI.lua_tostring(L, 3); + System.Action _complete = translator.GetDelegate>(L, 4); + + gen_to_be_invoked.Put( _url, _body, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaCheckPurchaseOrderCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaCheckPurchaseOrderCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaCheckPurchaseConsumeCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaCheckPurchaseConsumeCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaFirstRequestCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaFirstRequestCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaCheckPurchaseIOSOrderCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaCheckPurchaseIOSOrderCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaCheckPurchaseIOSConsumeCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaCheckPurchaseIOSConsumeCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_luaCheckPurchaseOrderCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaCheckPurchaseOrderCallback = translator.GetDelegate>(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_luaCheckPurchaseConsumeCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaCheckPurchaseConsumeCallback = translator.GetDelegate>(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_luaFirstRequestCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaFirstRequestCallback = translator.GetDelegate>(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_luaCheckPurchaseIOSOrderCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaCheckPurchaseIOSOrderCallback = translator.GetDelegate>(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_luaCheckPurchaseIOSConsumeCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFParseClientManager gen_to_be_invoked = (BF.BFParseClientManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaCheckPurchaseIOSConsumeCallback = translator.GetDelegate>(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_BFPaySDKManagerWrap.cs b/Assets/XLua/Gen/BF_BFPaySDKManagerWrap.cs new file mode 100644 index 000000000..aba4d447f --- /dev/null +++ b/Assets/XLua/Gen/BF_BFPaySDKManagerWrap.cs @@ -0,0 +1,731 @@ +#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 BFBFPaySDKManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFPaySDKManager); + Utils.BeginObjectRegister(type, L, translator, 0, 14, 8, 7); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GoogleStoreConnectComplete", _m_GoogleStoreConnectComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Pay", _m_Pay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GooglePayComplete", _m_GooglePayComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetGoogleDelayPayCallback", _m_SetGoogleDelayPayCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ConsumePurchase", _m_ConsumePurchase); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GoogleConsumeComplete", _m_GoogleConsumeComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ConnectGoogleStore", _m_ConnectGoogleStore); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "QueryProductInfo", _m_QueryProductInfo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "QueryProductOver", _m_QueryProductOver); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "QueryUncompleteOrder", _m_QueryUncompleteOrder); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "QueryUncompleteOrderFinish", _m_QueryUncompleteOrderFinish); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "QuerySubscribeInfo", _m_QuerySubscribeInfo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "QuerySubscribeInfoFinish", _m_QuerySubscribeInfoFinish); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ConnectStoreSucc", _g_get_ConnectStoreSucc); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaPayCallback", _g_get_luaPayCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaDelayPayCallback", _g_get_luaDelayPayCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaQueryProductCallback", _g_get_luaQueryProductCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaQueryUncompleteOrderCallback", _g_get_luaQueryUncompleteOrderCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaQuerySubscribeInfoCallback", _g_get_luaQuerySubscribeInfoCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaConnectGoogleStoreCallback", _g_get_luaConnectGoogleStoreCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaConsumeCallback", _g_get_luaConsumeCallback); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaPayCallback", _s_set_luaPayCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaDelayPayCallback", _s_set_luaDelayPayCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaQueryProductCallback", _s_set_luaQueryProductCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaQueryUncompleteOrderCallback", _s_set_luaQueryUncompleteOrderCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaQuerySubscribeInfoCallback", _s_set_luaQuerySubscribeInfoCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaConnectGoogleStoreCallback", _s_set_luaConnectGoogleStoreCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaConsumeCallback", _s_set_luaConsumeCallback); + + + 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.BFPaySDKManager(); + 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.BFPaySDKManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFPaySDKManager gen_to_be_invoked = (BF.BFPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GoogleStoreConnectComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFPaySDKManager gen_to_be_invoked = (BF.BFPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + bool _success = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.GoogleStoreConnectComplete( _success ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Pay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFPaySDKManager gen_to_be_invoked = (BF.BFPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _payType = LuaAPI.lua_tostring(L, 2); + string _productId = LuaAPI.lua_tostring(L, 3); + string _customMsg = LuaAPI.lua_tostring(L, 4); + System.Action _callback = translator.GetDelegate>(L, 5); + + gen_to_be_invoked.Pay( _payType, _productId, _customMsg, _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GooglePayComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFPaySDKManager gen_to_be_invoked = (BF.BFPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + int _code = LuaAPI.xlua_tointeger(L, 2); + string _result = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.GooglePayComplete( _code, _result ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetGoogleDelayPayCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFPaySDKManager gen_to_be_invoked = (BF.BFPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetGoogleDelayPayCallback( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ConsumePurchase(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFPaySDKManager gen_to_be_invoked = (BF.BFPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _token = LuaAPI.lua_tostring(L, 2); + System.Action _callback = translator.GetDelegate>(L, 3); + + gen_to_be_invoked.ConsumePurchase( _token, _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GoogleConsumeComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFPaySDKManager gen_to_be_invoked = (BF.BFPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + int _code = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.GoogleConsumeComplete( _code ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ConnectGoogleStore(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFPaySDKManager gen_to_be_invoked = (BF.BFPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.ConnectGoogleStore( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_QueryProductInfo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFPaySDKManager gen_to_be_invoked = (BF.BFPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _payType = LuaAPI.lua_tostring(L, 2); + string _productJson = LuaAPI.lua_tostring(L, 3); + System.Action _callback = translator.GetDelegate>(L, 4); + + gen_to_be_invoked.QueryProductInfo( _payType, _productJson, _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_QueryProductOver(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFPaySDKManager gen_to_be_invoked = (BF.BFPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + bool _succ = LuaAPI.lua_toboolean(L, 2); + string _result = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.QueryProductOver( _succ, _result ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_QueryUncompleteOrder(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFPaySDKManager gen_to_be_invoked = (BF.BFPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _payType = LuaAPI.lua_tostring(L, 2); + System.Action _callback = translator.GetDelegate>(L, 3); + + gen_to_be_invoked.QueryUncompleteOrder( _payType, _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_QueryUncompleteOrderFinish(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFPaySDKManager gen_to_be_invoked = (BF.BFPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _result = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.QueryUncompleteOrderFinish( _result ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_QuerySubscribeInfo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFPaySDKManager gen_to_be_invoked = (BF.BFPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _payType = LuaAPI.lua_tostring(L, 2); + System.Action _callback = translator.GetDelegate>(L, 3); + + gen_to_be_invoked.QuerySubscribeInfo( _payType, _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_QuerySubscribeInfoFinish(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFPaySDKManager gen_to_be_invoked = (BF.BFPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _result = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.QuerySubscribeInfoFinish( _result ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ConnectStoreSucc(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFPaySDKManager gen_to_be_invoked = (BF.BFPaySDKManager)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.ConnectStoreSucc); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaPayCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFPaySDKManager gen_to_be_invoked = (BF.BFPaySDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaPayCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaDelayPayCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFPaySDKManager gen_to_be_invoked = (BF.BFPaySDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaDelayPayCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaQueryProductCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFPaySDKManager gen_to_be_invoked = (BF.BFPaySDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaQueryProductCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaQueryUncompleteOrderCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFPaySDKManager gen_to_be_invoked = (BF.BFPaySDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaQueryUncompleteOrderCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaQuerySubscribeInfoCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFPaySDKManager gen_to_be_invoked = (BF.BFPaySDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaQuerySubscribeInfoCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaConnectGoogleStoreCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFPaySDKManager gen_to_be_invoked = (BF.BFPaySDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaConnectGoogleStoreCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaConsumeCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFPaySDKManager gen_to_be_invoked = (BF.BFPaySDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaConsumeCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_luaPayCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFPaySDKManager gen_to_be_invoked = (BF.BFPaySDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaPayCallback = translator.GetDelegate>(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_luaDelayPayCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFPaySDKManager gen_to_be_invoked = (BF.BFPaySDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaDelayPayCallback = translator.GetDelegate>(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_luaQueryProductCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFPaySDKManager gen_to_be_invoked = (BF.BFPaySDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaQueryProductCallback = translator.GetDelegate>(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_luaQueryUncompleteOrderCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFPaySDKManager gen_to_be_invoked = (BF.BFPaySDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaQueryUncompleteOrderCallback = translator.GetDelegate>(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_luaQuerySubscribeInfoCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFPaySDKManager gen_to_be_invoked = (BF.BFPaySDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaQuerySubscribeInfoCallback = translator.GetDelegate>(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_luaConnectGoogleStoreCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFPaySDKManager gen_to_be_invoked = (BF.BFPaySDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaConnectGoogleStoreCallback = translator.GetDelegate>(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_luaConsumeCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFPaySDKManager gen_to_be_invoked = (BF.BFPaySDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaConsumeCallback = translator.GetDelegate>(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_BFPlatformWrap.cs b/Assets/XLua/Gen/BF_BFPlatformWrap.cs new file mode 100644 index 000000000..3965c8611 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFPlatformWrap.cs @@ -0,0 +1,840 @@ +#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 BFBFPlatformWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFPlatform); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 34, 2, 1); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetClusterType", _m_GetClusterType_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IsLoginCenterConfigValid", _m_IsLoginCenterConfigValid_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetLoginCenterConfigValid", _m_SetLoginCenterConfigValid_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IsPublishChannel", _m_IsPublishChannel_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IsRuPackage", _m_IsRuPackage_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IsSupportRuPay", _m_IsSupportRuPay_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IsSupportRuStoreReview", _m_IsSupportRuStoreReview_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IsSupportFB", _m_IsSupportFB_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IsSupportGDPR", _m_IsSupportGDPR_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IsSupportFBAD", _m_IsSupportFBAD_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IsSupportVK", _m_IsSupportVK_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetCurrentGateInfo", _m_GetCurrentGateInfo_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetMainGateURL", _m_GetMainGateURL_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetMainGatePort", _m_GetMainGatePort_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetChatGateURL", _m_GetChatGateURL_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetChatGatePort", _m_GetChatGatePort_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetVsnHttpsInfo", _m_GetVsnHttpsInfo_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetVsnHttpURL", _m_GetVsnHttpURL_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetVsnHttpPort", _m_GetVsnHttpPort_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetLoginCenterURL", _m_GetLoginCenterURL_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetPayCenterURL", _m_GetPayCenterURL_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetCommunityWebURL", _m_GetCommunityWebURL_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetCommunitySrvURL", _m_GetCommunitySrvURL_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetAicsHttpURL", _m_GetAicsHttpURL_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetAicsWebSocketURL", _m_GetAicsWebSocketURL_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IsSupportHWPay", _m_IsSupportHWPay_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetLanguageInfo", _m_GetLanguageInfo_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetCurrentLanguageInfo", _m_GetCurrentLanguageInfo_xlua_st_); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ANDROID_GP_PACKAGE_NAME", BF.BFPlatform.ANDROID_GP_PACKAGE_NAME); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ANDROID_GP_PACKAGE_NAME_GLOBAL", BF.BFPlatform.ANDROID_GP_PACKAGE_NAME_GLOBAL); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ANDROID_GP_PACKAGE_NAME_RU", BF.BFPlatform.ANDROID_GP_PACKAGE_NAME_RU); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ANDROID_GP_PACKAGE_NAME_RUSTORE", BF.BFPlatform.ANDROID_GP_PACKAGE_NAME_RUSTORE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ANDROID_GP_PACKAGE_NAME_RU_HW", BF.BFPlatform.ANDROID_GP_PACKAGE_NAME_RU_HW); + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "Identifier", _g_get_Identifier); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "languageInfos", _g_get_languageInfos); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "languageInfos", _s_set_languageInfos); + + + 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.BFPlatform(); + 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.BFPlatform constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetClusterType_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = BF.BFPlatform.GetClusterType( ); + 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_IsLoginCenterConfigValid_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.BFPlatform.IsLoginCenterConfigValid( ); + 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_SetLoginCenterConfigValid_xlua_st_(RealStatePtr L) + { + try { + + + + + { + bool _valid = LuaAPI.lua_toboolean(L, 1); + + BF.BFPlatform.SetLoginCenterConfigValid( _valid ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsPublishChannel_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.BFPlatform.IsPublishChannel( ); + 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_IsRuPackage_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.BFPlatform.IsRuPackage( ); + 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_IsSupportRuPay_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.BFPlatform.IsSupportRuPay( ); + 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_IsSupportRuStoreReview_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.BFPlatform.IsSupportRuStoreReview( ); + 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_IsSupportFB_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.BFPlatform.IsSupportFB( ); + 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_IsSupportGDPR_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.BFPlatform.IsSupportGDPR( ); + 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_IsSupportFBAD_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.BFPlatform.IsSupportFBAD( ); + 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_IsSupportVK_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.BFPlatform.IsSupportVK( ); + 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_GetCurrentGateInfo_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = BF.BFPlatform.GetCurrentGateInfo( ); + 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_GetMainGateURL_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.BFPlatform.GetMainGateURL( ); + 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 _m_GetMainGatePort_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.BFPlatform.GetMainGatePort( ); + 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_GetChatGateURL_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.BFPlatform.GetChatGateURL( ); + 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 _m_GetChatGatePort_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.BFPlatform.GetChatGatePort( ); + 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_GetVsnHttpsInfo_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = BF.BFPlatform.GetVsnHttpsInfo( ); + 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_GetVsnHttpURL_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.BFPlatform.GetVsnHttpURL( ); + 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 _m_GetVsnHttpPort_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.BFPlatform.GetVsnHttpPort( ); + 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_GetLoginCenterURL_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.BFPlatform.GetLoginCenterURL( ); + 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 _m_GetPayCenterURL_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.BFPlatform.GetPayCenterURL( ); + 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 _m_GetCommunityWebURL_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.BFPlatform.GetCommunityWebURL( ); + 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 _m_GetCommunitySrvURL_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.BFPlatform.GetCommunitySrvURL( ); + 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 _m_GetAicsHttpURL_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.BFPlatform.GetAicsHttpURL( ); + 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 _m_GetAicsWebSocketURL_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.BFPlatform.GetAicsWebSocketURL( ); + 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 _m_IsSupportHWPay_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.BFPlatform.IsSupportHWPay( ); + 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_GetLanguageInfo_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _identifier = LuaAPI.lua_tostring(L, 1); + + var gen_ret = BF.BFPlatform.GetLanguageInfo( _identifier ); + 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_GetCurrentLanguageInfo_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = BF.BFPlatform.GetCurrentLanguageInfo( ); + 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_Identifier(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, BF.BFPlatform.Identifier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_languageInfos(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, BF.BFPlatform.languageInfos); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_languageInfos(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + BF.BFPlatform.languageInfos = (System.Collections.Generic.Dictionary)translator.GetObject(L, 1, 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/BF_BFRuPaySDKManagerWrap.cs b/Assets/XLua/Gen/BF_BFRuPaySDKManagerWrap.cs new file mode 100644 index 000000000..041193b0a --- /dev/null +++ b/Assets/XLua/Gen/BF_BFRuPaySDKManagerWrap.cs @@ -0,0 +1,547 @@ +#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 BFBFRuPaySDKManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFRuPaySDKManager); + Utils.BeginObjectRegister(type, L, translator, 0, 11, 5, 4); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CheckStoreValid", _m_CheckStoreValid); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CheckStoreValidComplete", _m_CheckStoreValidComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "QueryProductInfo", _m_QueryProductInfo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "QueryProductComplete", _m_QueryProductComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Pay", _m_Pay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PayComplete", _m_PayComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ConsumePurchase", _m_ConsumePurchase); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ConsumeComplete", _m_ConsumeComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "QueryUncompleteOrder", _m_QueryUncompleteOrder); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "QueryUncompleteOrderFinish", _m_QueryUncompleteOrderFinish); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "StoreValid", _g_get_StoreValid); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaPayCallback", _g_get_luaPayCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaQueryProductCallback", _g_get_luaQueryProductCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaQueryUncompleteOrderCallback", _g_get_luaQueryUncompleteOrderCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaConsumeCallback", _g_get_luaConsumeCallback); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaPayCallback", _s_set_luaPayCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaQueryProductCallback", _s_set_luaQueryProductCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaQueryUncompleteOrderCallback", _s_set_luaQueryUncompleteOrderCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaConsumeCallback", _s_set_luaConsumeCallback); + + + 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.BFRuPaySDKManager(); + 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.BFRuPaySDKManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFRuPaySDKManager gen_to_be_invoked = (BF.BFRuPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CheckStoreValid(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFRuPaySDKManager gen_to_be_invoked = (BF.BFRuPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CheckStoreValid( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CheckStoreValidComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFRuPaySDKManager gen_to_be_invoked = (BF.BFRuPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + bool _success = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.CheckStoreValidComplete( _success ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_QueryProductInfo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFRuPaySDKManager gen_to_be_invoked = (BF.BFRuPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _productJson = LuaAPI.lua_tostring(L, 2); + System.Action _callback = translator.GetDelegate>(L, 3); + + gen_to_be_invoked.QueryProductInfo( _productJson, _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_QueryProductComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFRuPaySDKManager gen_to_be_invoked = (BF.BFRuPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + bool _succ = LuaAPI.lua_toboolean(L, 2); + string _result = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.QueryProductComplete( _succ, _result ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Pay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFRuPaySDKManager gen_to_be_invoked = (BF.BFRuPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _payType = LuaAPI.lua_tostring(L, 2); + string _productId = LuaAPI.lua_tostring(L, 3); + string _customMsg = LuaAPI.lua_tostring(L, 4); + System.Action _callback = translator.GetDelegate>(L, 5); + + gen_to_be_invoked.Pay( _payType, _productId, _customMsg, _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PayComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFRuPaySDKManager gen_to_be_invoked = (BF.BFRuPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + int _code = LuaAPI.xlua_tointeger(L, 2); + string _result = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.PayComplete( _code, _result ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ConsumePurchase(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFRuPaySDKManager gen_to_be_invoked = (BF.BFRuPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _token = LuaAPI.lua_tostring(L, 2); + System.Action _callback = translator.GetDelegate>(L, 3); + + gen_to_be_invoked.ConsumePurchase( _token, _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ConsumeComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFRuPaySDKManager gen_to_be_invoked = (BF.BFRuPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + int _code = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.ConsumeComplete( _code ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_QueryUncompleteOrder(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFRuPaySDKManager gen_to_be_invoked = (BF.BFRuPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.QueryUncompleteOrder( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_QueryUncompleteOrderFinish(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFRuPaySDKManager gen_to_be_invoked = (BF.BFRuPaySDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _result = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.QueryUncompleteOrderFinish( _result ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_StoreValid(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFRuPaySDKManager gen_to_be_invoked = (BF.BFRuPaySDKManager)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.StoreValid); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaPayCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFRuPaySDKManager gen_to_be_invoked = (BF.BFRuPaySDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaPayCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaQueryProductCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFRuPaySDKManager gen_to_be_invoked = (BF.BFRuPaySDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaQueryProductCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaQueryUncompleteOrderCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFRuPaySDKManager gen_to_be_invoked = (BF.BFRuPaySDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaQueryUncompleteOrderCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaConsumeCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFRuPaySDKManager gen_to_be_invoked = (BF.BFRuPaySDKManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaConsumeCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_luaPayCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFRuPaySDKManager gen_to_be_invoked = (BF.BFRuPaySDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaPayCallback = translator.GetDelegate>(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_luaQueryProductCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFRuPaySDKManager gen_to_be_invoked = (BF.BFRuPaySDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaQueryProductCallback = translator.GetDelegate>(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_luaQueryUncompleteOrderCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFRuPaySDKManager gen_to_be_invoked = (BF.BFRuPaySDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaQueryUncompleteOrderCallback = translator.GetDelegate>(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_luaConsumeCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFRuPaySDKManager gen_to_be_invoked = (BF.BFRuPaySDKManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaConsumeCallback = translator.GetDelegate>(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_BFScrollRectBaseWrap.cs b/Assets/XLua/Gen/BF_BFScrollRectBaseWrap.cs new file mode 100644 index 000000000..bfe815b8d --- /dev/null +++ b/Assets/XLua/Gen/BF_BFScrollRectBaseWrap.cs @@ -0,0 +1,577 @@ +#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 BFBFScrollRectBaseWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFScrollRectBase); + Utils.BeginObjectRegister(type, L, translator, 0, 15, 3, 2); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRefreshAction", _m_SetRefreshAction); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetOnInstantiateCellAction", _m_SetOnInstantiateCellAction); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSelectedAction", _m_SetSelectedAction); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSelectedIndex", _m_GetSelectedIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAnchoredPositionChange", _m_SetAnchoredPositionChange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefillCells", _m_RefillCells); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTotalCount", _m_SetTotalCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshAll", _m_RefreshAll); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearCells", _m_ClearCells); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSelected", _m_SetSelected); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AnchoredPositionChange", _m_AnchoredPositionChange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "MoveToIndex", _m_MoveToIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveCell", _m_RemoveCell); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBeginDrag", _m_OnBeginDrag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnEndDrag", _m_OnEndDrag); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ContentTrans", _g_get_ContentTrans); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isDrag", _g_get_isDrag); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "contentTrans", _g_get_contentTrans); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "isDrag", _s_set_isDrag); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "contentTrans", _s_set_contentTrans); + + + 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, "BF.BFScrollRectBase does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRefreshAction(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectBase gen_to_be_invoked = (BF.BFScrollRectBase)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetRefreshAction( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetOnInstantiateCellAction(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectBase gen_to_be_invoked = (BF.BFScrollRectBase)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetOnInstantiateCellAction( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSelectedAction(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectBase gen_to_be_invoked = (BF.BFScrollRectBase)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetSelectedAction( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetSelectedIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectBase gen_to_be_invoked = (BF.BFScrollRectBase)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetSelectedIndex( ); + 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_SetAnchoredPositionChange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectBase gen_to_be_invoked = (BF.BFScrollRectBase)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetAnchoredPositionChange( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RefillCells(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectBase gen_to_be_invoked = (BF.BFScrollRectBase)translator.FastGetCSObj(L, 1); + + + + { + int _totalCount = LuaAPI.xlua_tointeger(L, 2); + int _targetIndex = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.RefillCells( _totalCount, _targetIndex ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTotalCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectBase gen_to_be_invoked = (BF.BFScrollRectBase)translator.FastGetCSObj(L, 1); + + + + { + int _totalCount = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetTotalCount( _totalCount ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RefreshAll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectBase gen_to_be_invoked = (BF.BFScrollRectBase)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RefreshAll( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearCells(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectBase gen_to_be_invoked = (BF.BFScrollRectBase)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearCells( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSelected(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectBase gen_to_be_invoked = (BF.BFScrollRectBase)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetSelected( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AnchoredPositionChange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectBase gen_to_be_invoked = (BF.BFScrollRectBase)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.AnchoredPositionChange( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_MoveToIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectBase gen_to_be_invoked = (BF.BFScrollRectBase)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.MoveToIndex( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveCell(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectBase gen_to_be_invoked = (BF.BFScrollRectBase)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.RemoveCell( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnBeginDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectBase gen_to_be_invoked = (BF.BFScrollRectBase)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnBeginDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnEndDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectBase gen_to_be_invoked = (BF.BFScrollRectBase)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnEndDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ContentTrans(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectBase gen_to_be_invoked = (BF.BFScrollRectBase)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.ContentTrans); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isDrag(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectBase gen_to_be_invoked = (BF.BFScrollRectBase)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isDrag); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_contentTrans(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectBase gen_to_be_invoked = (BF.BFScrollRectBase)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.contentTrans); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_isDrag(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectBase gen_to_be_invoked = (BF.BFScrollRectBase)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.isDrag = 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_contentTrans(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectBase gen_to_be_invoked = (BF.BFScrollRectBase)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.contentTrans = (UnityEngine.RectTransform)translator.GetObject(L, 2, typeof(UnityEngine.RectTransform)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_BFScrollRectCommonWrap.cs b/Assets/XLua/Gen/BF_BFScrollRectCommonWrap.cs new file mode 100644 index 000000000..23d776f9a --- /dev/null +++ b/Assets/XLua/Gen/BF_BFScrollRectCommonWrap.cs @@ -0,0 +1,915 @@ +#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 BFBFScrollRectCommonWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFScrollRectCommon); + Utils.BeginObjectRegister(type, L, translator, 0, 17, 11, 11); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefillCells", _m_RefillCells); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTotalCount", _m_SetTotalCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshAll", _m_RefreshAll); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSelected", _m_SetSelected); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearCells", _m_ClearCells); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AnchoredPositionChange", _m_AnchoredPositionChange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "MoveToIndex", _m_MoveToIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveCell", _m_RemoveCell); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "StopMovement", _m_StopMovement); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateAllCellPosition", _m_UpdateAllCellPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetCellWidth", _m_SetCellWidth); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetCellHeight", _m_SetCellHeight); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPerLineNum", _m_SetPerLineNum); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTopRecoveryOffset", _m_SetTopRecoveryOffset); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetDownRecoveryOffset", _m_SetDownRecoveryOffset); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTopRecoveryOffset", _m_GetTopRecoveryOffset); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetDownRecoveryOffset", _m_GetDownRecoveryOffset); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "CellWidth", _g_get_CellWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "CellHeight", _g_get_CellHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bfCell", _g_get_bfCell); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "topRecoveryOffset", _g_get_topRecoveryOffset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "downRecoveryOffset", _g_get_downRecoveryOffset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "direction", _g_get_direction); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "reverse", _g_get_reverse); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "centerWhenNotFull", _g_get_centerWhenNotFull); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "cellWidth", _g_get_cellWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "cellHeight", _g_get_cellHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "perLineNum", _g_get_perLineNum); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "CellWidth", _s_set_CellWidth); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "CellHeight", _s_set_CellHeight); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "bfCell", _s_set_bfCell); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "topRecoveryOffset", _s_set_topRecoveryOffset); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "downRecoveryOffset", _s_set_downRecoveryOffset); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "direction", _s_set_direction); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "reverse", _s_set_reverse); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "centerWhenNotFull", _s_set_centerWhenNotFull); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "cellWidth", _s_set_cellWidth); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "cellHeight", _s_set_cellHeight); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "perLineNum", _s_set_perLineNum); + + + 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.BFScrollRectCommon(); + 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.BFScrollRectCommon constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RefillCells(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + + + + { + int _totalCount = LuaAPI.xlua_tointeger(L, 2); + int _targetIndex = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.RefillCells( _totalCount, _targetIndex ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTotalCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + + + + { + int _totalCount = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetTotalCount( _totalCount ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RefreshAll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RefreshAll( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSelected(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetSelected( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearCells(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearCells( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AnchoredPositionChange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.AnchoredPositionChange( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_MoveToIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.MoveToIndex( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveCell(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.RemoveCell( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_StopMovement(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.StopMovement( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UpdateAllCellPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.UpdateAllCellPosition( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetCellWidth(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + + + + { + float _width = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.SetCellWidth( _width ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetCellHeight(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + + + + { + float _height = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.SetCellHeight( _height ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetPerLineNum(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + + + + { + int _num = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetPerLineNum( _num ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTopRecoveryOffset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + + + + { + int _num = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetTopRecoveryOffset( _num ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetDownRecoveryOffset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + + + + { + int _num = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetDownRecoveryOffset( _num ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetTopRecoveryOffset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetTopRecoveryOffset( ); + 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_GetDownRecoveryOffset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetDownRecoveryOffset( ); + 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 _g_get_CellWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.CellWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_CellHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.CellHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bfCell(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.bfCell); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_topRecoveryOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.topRecoveryOffset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_downRecoveryOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.downRecoveryOffset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_direction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.direction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_reverse(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.reverse); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_centerWhenNotFull(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.centerWhenNotFull); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cellWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.cellWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cellHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.cellHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_perLineNum(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.perLineNum); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_CellWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.CellWidth = (float)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_CellHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.CellHeight = (float)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_bfCell(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.bfCell = (BF.BFCell)translator.GetObject(L, 2, typeof(BF.BFCell)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_topRecoveryOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.topRecoveryOffset = 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_downRecoveryOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.downRecoveryOffset = 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_direction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + BF.BFUIDirection gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.direction = 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_reverse(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.reverse = 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_centerWhenNotFull(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.centerWhenNotFull = 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_cellWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.cellWidth = (float)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_cellHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.cellHeight = (float)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_perLineNum(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectCommon gen_to_be_invoked = (BF.BFScrollRectCommon)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.perLineNum = 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_BFScrollRectGridWrap.cs b/Assets/XLua/Gen/BF_BFScrollRectGridWrap.cs new file mode 100644 index 000000000..01b44b810 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFScrollRectGridWrap.cs @@ -0,0 +1,503 @@ +#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 BFBFScrollRectGridWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFScrollRectGrid); + Utils.BeginObjectRegister(type, L, translator, 0, 7, 7, 7); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefillCells", _m_RefillCells); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTotalCount", _m_SetTotalCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSelected", _m_SetSelected); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshAll", _m_RefreshAll); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearCells", _m_ClearCells); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AnchoredPositionChange", _m_AnchoredPositionChange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "MoveToIndex", _m_MoveToIndex); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bfCell", _g_get_bfCell); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "spacing", _g_get_spacing); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "padding", _g_get_padding); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "topRecoveryOffset", _g_get_topRecoveryOffset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "downRecoveryOffset", _g_get_downRecoveryOffset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preLineCount", _g_get_preLineCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "direction", _g_get_direction); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "bfCell", _s_set_bfCell); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "spacing", _s_set_spacing); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "padding", _s_set_padding); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "topRecoveryOffset", _s_set_topRecoveryOffset); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "downRecoveryOffset", _s_set_downRecoveryOffset); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "preLineCount", _s_set_preLineCount); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "direction", _s_set_direction); + + + 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.BFScrollRectGrid(); + 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.BFScrollRectGrid constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RefillCells(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectGrid gen_to_be_invoked = (BF.BFScrollRectGrid)translator.FastGetCSObj(L, 1); + + + + { + int _totalCount = LuaAPI.xlua_tointeger(L, 2); + int _targetIndex = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.RefillCells( _totalCount, _targetIndex ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTotalCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectGrid gen_to_be_invoked = (BF.BFScrollRectGrid)translator.FastGetCSObj(L, 1); + + + + { + int _totalCount = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetTotalCount( _totalCount ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSelected(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectGrid gen_to_be_invoked = (BF.BFScrollRectGrid)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetSelected( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RefreshAll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectGrid gen_to_be_invoked = (BF.BFScrollRectGrid)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RefreshAll( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearCells(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectGrid gen_to_be_invoked = (BF.BFScrollRectGrid)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearCells( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AnchoredPositionChange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectGrid gen_to_be_invoked = (BF.BFScrollRectGrid)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.AnchoredPositionChange( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_MoveToIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectGrid gen_to_be_invoked = (BF.BFScrollRectGrid)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.MoveToIndex( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bfCell(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectGrid gen_to_be_invoked = (BF.BFScrollRectGrid)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.bfCell); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_spacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectGrid gen_to_be_invoked = (BF.BFScrollRectGrid)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.spacing); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_padding(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectGrid gen_to_be_invoked = (BF.BFScrollRectGrid)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.padding); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_topRecoveryOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectGrid gen_to_be_invoked = (BF.BFScrollRectGrid)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.topRecoveryOffset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_downRecoveryOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectGrid gen_to_be_invoked = (BF.BFScrollRectGrid)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.downRecoveryOffset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preLineCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectGrid gen_to_be_invoked = (BF.BFScrollRectGrid)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.preLineCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_direction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectGrid gen_to_be_invoked = (BF.BFScrollRectGrid)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.direction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_bfCell(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectGrid gen_to_be_invoked = (BF.BFScrollRectGrid)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.bfCell = (BF.BFCell)translator.GetObject(L, 2, typeof(BF.BFCell)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_spacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectGrid gen_to_be_invoked = (BF.BFScrollRectGrid)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.spacing = (float)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_padding(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectGrid gen_to_be_invoked = (BF.BFScrollRectGrid)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.padding = (float)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_topRecoveryOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectGrid gen_to_be_invoked = (BF.BFScrollRectGrid)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.topRecoveryOffset = (float)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_downRecoveryOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectGrid gen_to_be_invoked = (BF.BFScrollRectGrid)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.downRecoveryOffset = (float)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_preLineCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectGrid gen_to_be_invoked = (BF.BFScrollRectGrid)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.preLineCount = 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_direction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectGrid gen_to_be_invoked = (BF.BFScrollRectGrid)translator.FastGetCSObj(L, 1); + BF.BFUIDirection gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.direction = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_BFScrollRectMultCellWrap.cs b/Assets/XLua/Gen/BF_BFScrollRectMultCellWrap.cs new file mode 100644 index 000000000..03184aa67 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFScrollRectMultCellWrap.cs @@ -0,0 +1,503 @@ +#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 BFBFScrollRectMultCellWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFScrollRectMultCell); + Utils.BeginObjectRegister(type, L, translator, 0, 7, 7, 7); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetGetCellIndexFunc", _m_SetGetCellIndexFunc); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefillCells", _m_RefillCells); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTotalCount", _m_SetTotalCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSelected", _m_SetSelected); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshAll", _m_RefreshAll); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearCells", _m_ClearCells); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AnchoredPositionChange", _m_AnchoredPositionChange); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bfCells", _g_get_bfCells); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "spacing", _g_get_spacing); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "padding", _g_get_padding); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "topRecoveryOffset", _g_get_topRecoveryOffset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "downRecoveryOffset", _g_get_downRecoveryOffset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preLineCount", _g_get_preLineCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "direction", _g_get_direction); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "bfCells", _s_set_bfCells); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "spacing", _s_set_spacing); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "padding", _s_set_padding); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "topRecoveryOffset", _s_set_topRecoveryOffset); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "downRecoveryOffset", _s_set_downRecoveryOffset); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "preLineCount", _s_set_preLineCount); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "direction", _s_set_direction); + + + 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.BFScrollRectMultCell(); + 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.BFScrollRectMultCell constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetGetCellIndexFunc(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectMultCell gen_to_be_invoked = (BF.BFScrollRectMultCell)translator.FastGetCSObj(L, 1); + + + + { + System.Func _getCellIndex = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetGetCellIndexFunc( _getCellIndex ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RefillCells(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectMultCell gen_to_be_invoked = (BF.BFScrollRectMultCell)translator.FastGetCSObj(L, 1); + + + + { + int _totalCount = LuaAPI.xlua_tointeger(L, 2); + int _targetIndex = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.RefillCells( _totalCount, _targetIndex ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTotalCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectMultCell gen_to_be_invoked = (BF.BFScrollRectMultCell)translator.FastGetCSObj(L, 1); + + + + { + int _totalCount = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetTotalCount( _totalCount ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSelected(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectMultCell gen_to_be_invoked = (BF.BFScrollRectMultCell)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetSelected( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RefreshAll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectMultCell gen_to_be_invoked = (BF.BFScrollRectMultCell)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RefreshAll( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearCells(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectMultCell gen_to_be_invoked = (BF.BFScrollRectMultCell)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearCells( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AnchoredPositionChange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectMultCell gen_to_be_invoked = (BF.BFScrollRectMultCell)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.AnchoredPositionChange( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bfCells(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectMultCell gen_to_be_invoked = (BF.BFScrollRectMultCell)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.bfCells); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_spacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectMultCell gen_to_be_invoked = (BF.BFScrollRectMultCell)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.spacing); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_padding(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectMultCell gen_to_be_invoked = (BF.BFScrollRectMultCell)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.padding); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_topRecoveryOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectMultCell gen_to_be_invoked = (BF.BFScrollRectMultCell)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.topRecoveryOffset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_downRecoveryOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectMultCell gen_to_be_invoked = (BF.BFScrollRectMultCell)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.downRecoveryOffset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preLineCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectMultCell gen_to_be_invoked = (BF.BFScrollRectMultCell)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.preLineCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_direction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectMultCell gen_to_be_invoked = (BF.BFScrollRectMultCell)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.direction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_bfCells(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectMultCell gen_to_be_invoked = (BF.BFScrollRectMultCell)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.bfCells = (BF.BFCell[])translator.GetObject(L, 2, typeof(BF.BFCell[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_spacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectMultCell gen_to_be_invoked = (BF.BFScrollRectMultCell)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.spacing = (float)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_padding(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectMultCell gen_to_be_invoked = (BF.BFScrollRectMultCell)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.padding = (float)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_topRecoveryOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectMultCell gen_to_be_invoked = (BF.BFScrollRectMultCell)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.topRecoveryOffset = (float)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_downRecoveryOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectMultCell gen_to_be_invoked = (BF.BFScrollRectMultCell)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.downRecoveryOffset = (float)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_preLineCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectMultCell gen_to_be_invoked = (BF.BFScrollRectMultCell)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.preLineCount = 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_direction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectMultCell gen_to_be_invoked = (BF.BFScrollRectMultCell)translator.FastGetCSObj(L, 1); + BF.BFUIDirection gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.direction = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_BFScrollRectMultSizeWrap.cs b/Assets/XLua/Gen/BF_BFScrollRectMultSizeWrap.cs new file mode 100644 index 000000000..bd3d82b29 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFScrollRectMultSizeWrap.cs @@ -0,0 +1,443 @@ +#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 BFBFScrollRectMultSizeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFScrollRectMultSize); + Utils.BeginObjectRegister(type, L, translator, 0, 6, 6, 6); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefillCells", _m_RefillCells); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTotalCount", _m_SetTotalCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshAll", _m_RefreshAll); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSelected", _m_SetSelected); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearCells", _m_ClearCells); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AnchoredPositionChange", _m_AnchoredPositionChange); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bfCell", _g_get_bfCell); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "spacing", _g_get_spacing); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "topRecoveryOffset", _g_get_topRecoveryOffset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "downRecoveryOffset", _g_get_downRecoveryOffset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "direction", _g_get_direction); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "reverse", _g_get_reverse); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "bfCell", _s_set_bfCell); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "spacing", _s_set_spacing); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "topRecoveryOffset", _s_set_topRecoveryOffset); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "downRecoveryOffset", _s_set_downRecoveryOffset); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "direction", _s_set_direction); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "reverse", _s_set_reverse); + + + 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.BFScrollRectMultSize(); + 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.BFScrollRectMultSize constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RefillCells(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectMultSize gen_to_be_invoked = (BF.BFScrollRectMultSize)translator.FastGetCSObj(L, 1); + + + + { + int _totalCount = LuaAPI.xlua_tointeger(L, 2); + int _targetIndex = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.RefillCells( _totalCount, _targetIndex ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTotalCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectMultSize gen_to_be_invoked = (BF.BFScrollRectMultSize)translator.FastGetCSObj(L, 1); + + + + { + int _totalCount = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetTotalCount( _totalCount ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RefreshAll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectMultSize gen_to_be_invoked = (BF.BFScrollRectMultSize)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RefreshAll( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSelected(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectMultSize gen_to_be_invoked = (BF.BFScrollRectMultSize)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetSelected( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearCells(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectMultSize gen_to_be_invoked = (BF.BFScrollRectMultSize)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearCells( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AnchoredPositionChange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFScrollRectMultSize gen_to_be_invoked = (BF.BFScrollRectMultSize)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.AnchoredPositionChange( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bfCell(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectMultSize gen_to_be_invoked = (BF.BFScrollRectMultSize)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.bfCell); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_spacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectMultSize gen_to_be_invoked = (BF.BFScrollRectMultSize)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.spacing); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_topRecoveryOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectMultSize gen_to_be_invoked = (BF.BFScrollRectMultSize)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.topRecoveryOffset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_downRecoveryOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectMultSize gen_to_be_invoked = (BF.BFScrollRectMultSize)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.downRecoveryOffset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_direction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectMultSize gen_to_be_invoked = (BF.BFScrollRectMultSize)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.direction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_reverse(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectMultSize gen_to_be_invoked = (BF.BFScrollRectMultSize)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.reverse); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_bfCell(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectMultSize gen_to_be_invoked = (BF.BFScrollRectMultSize)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.bfCell = (BF.BFCell)translator.GetObject(L, 2, typeof(BF.BFCell)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_spacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectMultSize gen_to_be_invoked = (BF.BFScrollRectMultSize)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.spacing = (float)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_topRecoveryOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectMultSize gen_to_be_invoked = (BF.BFScrollRectMultSize)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.topRecoveryOffset = (float)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_downRecoveryOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectMultSize gen_to_be_invoked = (BF.BFScrollRectMultSize)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.downRecoveryOffset = (float)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_direction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectMultSize gen_to_be_invoked = (BF.BFScrollRectMultSize)translator.FastGetCSObj(L, 1); + BF.BFUIDirection gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.direction = 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_reverse(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFScrollRectMultSize gen_to_be_invoked = (BF.BFScrollRectMultSize)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.reverse = LuaAPI.lua_toboolean(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_BFSliderWrap.cs b/Assets/XLua/Gen/BF_BFSliderWrap.cs new file mode 100644 index 000000000..5d08164c9 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFSliderWrap.cs @@ -0,0 +1,361 @@ +#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 BFBFSliderWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFSlider); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 11, 8); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sprite", _g_get_sprite); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fillDirection", _g_get_fillDirection); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "value", _g_get_value); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fillCenter", _g_get_fillCenter); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "pixelsPerUnitMultiplier", _g_get_pixelsPerUnitMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "pixelsPerUnit", _g_get_pixelsPerUnit); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "overrideSprite", _g_get_overrideSprite); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mainTexture", _g_get_mainTexture); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "hasBorder", _g_get_hasBorder); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "material", _g_get_material); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "alphaHitTestMinimumThreshold", _g_get_alphaHitTestMinimumThreshold); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sprite", _s_set_sprite); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fillDirection", _s_set_fillDirection); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "value", _s_set_value); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fillCenter", _s_set_fillCenter); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "pixelsPerUnitMultiplier", _s_set_pixelsPerUnitMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "overrideSprite", _s_set_overrideSprite); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "material", _s_set_material); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "alphaHitTestMinimumThreshold", _s_set_alphaHitTestMinimumThreshold); + + + 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, "BF.BFSlider does not have a constructor!"); + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sprite(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFSlider gen_to_be_invoked = (BF.BFSlider)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.sprite); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fillDirection(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFSlider gen_to_be_invoked = (BF.BFSlider)translator.FastGetCSObj(L, 1); + translator.PushBFBFSliderFillDirection(L, gen_to_be_invoked.fillDirection); + } 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); + + BF.BFSlider gen_to_be_invoked = (BF.BFSlider)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(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_fillCenter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFSlider gen_to_be_invoked = (BF.BFSlider)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.fillCenter); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_pixelsPerUnitMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFSlider gen_to_be_invoked = (BF.BFSlider)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.pixelsPerUnitMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_pixelsPerUnit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFSlider gen_to_be_invoked = (BF.BFSlider)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.pixelsPerUnit); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_overrideSprite(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFSlider gen_to_be_invoked = (BF.BFSlider)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.overrideSprite); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mainTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFSlider gen_to_be_invoked = (BF.BFSlider)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.mainTexture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_hasBorder(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFSlider gen_to_be_invoked = (BF.BFSlider)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hasBorder); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_material(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFSlider gen_to_be_invoked = (BF.BFSlider)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.material); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_alphaHitTestMinimumThreshold(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFSlider gen_to_be_invoked = (BF.BFSlider)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.alphaHitTestMinimumThreshold); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_sprite(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFSlider gen_to_be_invoked = (BF.BFSlider)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.sprite = (UnityEngine.Sprite)translator.GetObject(L, 2, typeof(UnityEngine.Sprite)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_fillDirection(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFSlider gen_to_be_invoked = (BF.BFSlider)translator.FastGetCSObj(L, 1); + BF.BFSlider.FillDirection gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.fillDirection = 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_value(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFSlider gen_to_be_invoked = (BF.BFSlider)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.value = (float)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_fillCenter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFSlider gen_to_be_invoked = (BF.BFSlider)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.fillCenter = 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_pixelsPerUnitMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFSlider gen_to_be_invoked = (BF.BFSlider)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.pixelsPerUnitMultiplier = (float)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_overrideSprite(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFSlider gen_to_be_invoked = (BF.BFSlider)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.overrideSprite = (UnityEngine.Sprite)translator.GetObject(L, 2, typeof(UnityEngine.Sprite)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_material(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFSlider gen_to_be_invoked = (BF.BFSlider)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.material = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_alphaHitTestMinimumThreshold(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFSlider gen_to_be_invoked = (BF.BFSlider)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.alphaHitTestMinimumThreshold = (float)LuaAPI.lua_tonumber(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_BFThirdReportSDKManagerWrap.cs b/Assets/XLua/Gen/BF_BFThirdReportSDKManagerWrap.cs new file mode 100644 index 000000000..29ebe7865 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFThirdReportSDKManagerWrap.cs @@ -0,0 +1,624 @@ +#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 BFBFThirdReportSDKManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFThirdReportSDKManager); + Utils.BeginObjectRegister(type, L, translator, 0, 17, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetThinkingAnalyticsAccountId", _m_SetThinkingAnalyticsAccountId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CalibrateTime", _m_CalibrateTime); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearThinkingAnalyticsAccountId", _m_ClearThinkingAnalyticsAccountId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAFConversionData", _m_GetAFConversionData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsGetConversionDataOver", _m_IsGetConversionDataOver); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAFAttributionData", _m_GetAFAttributionData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsGetAppOpenAttributionOver", _m_IsGetAppOpenAttributionOver); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsGetAFOnRequestResponse", _m_IsGetAFOnRequestResponse); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAFOnRequestResponseStatusCode", _m_GetAFOnRequestResponseStatusCode); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAFOnRequestResponseErrorDescription", _m_GetAFOnRequestResponseErrorDescription); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PostThinkingAnalyticsEvent", _m_PostThinkingAnalyticsEvent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PostThinkingAnalyticsEventName", _m_PostThinkingAnalyticsEventName); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PostThinkingAnalyticsEventProperties", _m_PostThinkingAnalyticsEventProperties); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PostAppsflyerEvent", _m_PostAppsflyerEvent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PostFireBaseEvent", _m_PostFireBaseEvent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LogAppsFlyerAdRevenue", _m_LogAppsFlyerAdRevenue); + + + + + + 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.BFThirdReportSDKManager(); + 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.BFThirdReportSDKManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFThirdReportSDKManager gen_to_be_invoked = (BF.BFThirdReportSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetThinkingAnalyticsAccountId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFThirdReportSDKManager gen_to_be_invoked = (BF.BFThirdReportSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _id = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SetThinkingAnalyticsAccountId( _id ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalibrateTime(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFThirdReportSDKManager gen_to_be_invoked = (BF.BFThirdReportSDKManager)translator.FastGetCSObj(L, 1); + + + + { + long _timestamp = LuaAPI.lua_toint64(L, 2); + + gen_to_be_invoked.CalibrateTime( _timestamp ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearThinkingAnalyticsAccountId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFThirdReportSDKManager gen_to_be_invoked = (BF.BFThirdReportSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearThinkingAnalyticsAccountId( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetAFConversionData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFThirdReportSDKManager gen_to_be_invoked = (BF.BFThirdReportSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetAFConversionData( ); + 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 _m_IsGetConversionDataOver(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFThirdReportSDKManager gen_to_be_invoked = (BF.BFThirdReportSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsGetConversionDataOver( ); + 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_GetAFAttributionData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFThirdReportSDKManager gen_to_be_invoked = (BF.BFThirdReportSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetAFAttributionData( ); + 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 _m_IsGetAppOpenAttributionOver(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFThirdReportSDKManager gen_to_be_invoked = (BF.BFThirdReportSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsGetAppOpenAttributionOver( ); + 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_IsGetAFOnRequestResponse(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFThirdReportSDKManager gen_to_be_invoked = (BF.BFThirdReportSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsGetAFOnRequestResponse( ); + 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_GetAFOnRequestResponseStatusCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFThirdReportSDKManager gen_to_be_invoked = (BF.BFThirdReportSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetAFOnRequestResponseStatusCode( ); + 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_GetAFOnRequestResponseErrorDescription(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFThirdReportSDKManager gen_to_be_invoked = (BF.BFThirdReportSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetAFOnRequestResponseErrorDescription( ); + 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 _m_PostThinkingAnalyticsEvent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFThirdReportSDKManager gen_to_be_invoked = (BF.BFThirdReportSDKManager)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 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 _eventName = LuaAPI.lua_tostring(L, 2); + string _data = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.PostThinkingAnalyticsEvent( _eventName, _data ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _eventName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.PostThinkingAnalyticsEvent( _eventName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.BFThirdReportSDKManager.PostThinkingAnalyticsEvent!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PostThinkingAnalyticsEventName(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFThirdReportSDKManager gen_to_be_invoked = (BF.BFThirdReportSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _eventName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.PostThinkingAnalyticsEventName( _eventName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PostThinkingAnalyticsEventProperties(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFThirdReportSDKManager gen_to_be_invoked = (BF.BFThirdReportSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _eventName = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 3, typeof(System.Collections.Generic.Dictionary)); + + gen_to_be_invoked.PostThinkingAnalyticsEventProperties( _eventName, _properties ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PostAppsflyerEvent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFThirdReportSDKManager gen_to_be_invoked = (BF.BFThirdReportSDKManager)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 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 _eventName = LuaAPI.lua_tostring(L, 2); + string _data = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.PostAppsflyerEvent( _eventName, _data ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _eventName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.PostAppsflyerEvent( _eventName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.BFThirdReportSDKManager.PostAppsflyerEvent!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PostFireBaseEvent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFThirdReportSDKManager gen_to_be_invoked = (BF.BFThirdReportSDKManager)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 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 _eventName = LuaAPI.lua_tostring(L, 2); + string _data = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.PostFireBaseEvent( _eventName, _data ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _eventName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.PostFireBaseEvent( _eventName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.BFThirdReportSDKManager.PostFireBaseEvent!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LogAppsFlyerAdRevenue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFThirdReportSDKManager gen_to_be_invoked = (BF.BFThirdReportSDKManager)translator.FastGetCSObj(L, 1); + + + + { + int _mediationNetwork = LuaAPI.xlua_tointeger(L, 2); + string _monetizationNetwork = LuaAPI.lua_tostring(L, 3); + double _eventRevenue = LuaAPI.lua_tonumber(L, 4); + string _data = LuaAPI.lua_tostring(L, 5); + + gen_to_be_invoked.LogAppsFlyerAdRevenue( _mediationNetwork, _monetizationNetwork, _eventRevenue, _data ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_BFTouchManagerWrap.cs b/Assets/XLua/Gen/BF_BFTouchManagerWrap.cs new file mode 100644 index 000000000..1b7065127 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFTouchManagerWrap.cs @@ -0,0 +1,765 @@ +#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 BFBFTouchManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFTouchManager); + Utils.BeginObjectRegister(type, L, translator, 0, 10, 11, 11); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetGuideMask", _m_SetGuideMask); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Destroy", _m_Destroy); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RaycastFindTrans", _m_RaycastFindTrans); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PointOverTargetLayer", _m_PointOverTargetLayer); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PointOverLayer", _m_PointOverLayer); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RaycastFind", _m_RaycastFind); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RaycastResultContains", _m_RaycastResultContains); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetFingers", _m_GetFingers); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Update", _m_Update); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onFinger", _g_get_onFinger); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onGesture", _g_get_onGesture); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fingers", _g_get_fingers); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "hitThresholdTime", _g_get_hitThresholdTime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "slideThresholdPixels", _g_get_slideThresholdPixels); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "targetLayers", _g_get_targetLayers); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "recordFingers", _g_get_recordFingers); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "recordThresholdPixels", _g_get_recordThresholdPixels); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "recordTimeLimit", _g_get_recordTimeLimit); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "simulateMultiFingers", _g_get_simulateMultiFingers); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "maxFinger", _g_get_maxFinger); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onFinger", _s_set_onFinger); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onGesture", _s_set_onGesture); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fingers", _s_set_fingers); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "hitThresholdTime", _s_set_hitThresholdTime); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "slideThresholdPixels", _s_set_slideThresholdPixels); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "targetLayers", _s_set_targetLayers); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "recordFingers", _s_set_recordFingers); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "recordThresholdPixels", _s_set_recordThresholdPixels); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "recordTimeLimit", _s_set_recordTimeLimit); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "simulateMultiFingers", _s_set_simulateMultiFingers); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "maxFinger", _s_set_maxFinger); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Create", _m_Create_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "BF.BFTouchManager does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Create_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = BF.BFTouchManager.Create( ); + 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_SetGuideMask(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + + + + { + bool _mask = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.SetGuideMask( _mask ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Destroy(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Destroy( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RaycastFindTrans(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector2 _screenPosition;translator.Get(L, 2, out _screenPosition); + + var gen_ret = gen_to_be_invoked.RaycastFindTrans( _screenPosition ); + 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_PointOverTargetLayer(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector2 _screenPosition;translator.Get(L, 2, out _screenPosition); + + var gen_ret = gen_to_be_invoked.PointOverTargetLayer( _screenPosition ); + 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_PointOverLayer(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector2 _screenPosition;translator.Get(L, 2, out _screenPosition); + UnityEngine.LayerMask _layer;translator.Get(L, 3, out _layer); + + var gen_ret = gen_to_be_invoked.PointOverLayer( _screenPosition, _layer ); + 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_RaycastFind(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector2 _screenPosition;translator.Get(L, 2, out _screenPosition); + + var gen_ret = gen_to_be_invoked.RaycastFind( _screenPosition ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector2 _screenPosition;translator.Get(L, 2, out _screenPosition); + UnityEngine.LayerMask _layerMask;translator.Get(L, 3, out _layerMask); + + var gen_ret = gen_to_be_invoked.RaycastFind( _screenPosition, _layerMask ); + 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.BFTouchManager.RaycastFind!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RaycastResultContains(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector2 _screenPosition;translator.Get(L, 2, out _screenPosition); + UnityEngine.Transform _transform = (UnityEngine.Transform)translator.GetObject(L, 3, typeof(UnityEngine.Transform)); + + var gen_ret = gen_to_be_invoked.RaycastResultContains( _screenPosition, _transform ); + 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_GetFingers(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + bool _ignoreIfStartedOverGui = LuaAPI.lua_toboolean(L, 2); + bool _ignoreIfOverGui = LuaAPI.lua_toboolean(L, 3); + int _fingerCount = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.GetFingers( _ignoreIfStartedOverGui, _ignoreIfOverGui, _fingerCount ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + bool _ignoreIfStartedOverGui = LuaAPI.lua_toboolean(L, 2); + bool _ignoreIfOverGui = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.GetFingers( _ignoreIfStartedOverGui, _ignoreIfOverGui ); + 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.BFTouchManager.GetFingers!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Update(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Update( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onFinger(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onFinger); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onGesture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onGesture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fingers(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.fingers); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_hitThresholdTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.hitThresholdTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_slideThresholdPixels(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.slideThresholdPixels); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_targetLayers(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.targetLayers); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_recordFingers(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.recordFingers); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_recordThresholdPixels(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.recordThresholdPixels); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_recordTimeLimit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.recordTimeLimit); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_simulateMultiFingers(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.simulateMultiFingers); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxFinger(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.maxFinger); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_onFinger(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onFinger = (BF.BFEvent)translator.GetObject(L, 2, typeof(BF.BFEvent)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_onGesture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onGesture = (BF.BFEvent>)translator.GetObject(L, 2, typeof(BF.BFEvent>)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_fingers(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.fingers = (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; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_hitThresholdTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.hitThresholdTime = (float)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_slideThresholdPixels(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.slideThresholdPixels = (float)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_targetLayers(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + UnityEngine.LayerMask gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.targetLayers = 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_recordFingers(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.recordFingers = 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_recordThresholdPixels(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.recordThresholdPixels = (float)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_recordTimeLimit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.recordTimeLimit = (float)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_simulateMultiFingers(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.simulateMultiFingers = 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_maxFinger(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchManager gen_to_be_invoked = (BF.BFTouchManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.maxFinger = 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_BFTouchSelectableWrap.cs b/Assets/XLua/Gen/BF_BFTouchSelectableWrap.cs new file mode 100644 index 000000000..89bea6408 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFTouchSelectableWrap.cs @@ -0,0 +1,269 @@ +#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 BFBFTouchSelectableWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFTouchSelectable); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 7, 5); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "OnEvent", _g_get_OnEvent); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "OnSelectGesture", _g_get_OnSelectGesture); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsSelected", _g_get_IsSelected); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsLongSelected", _g_get_IsLongSelected); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "allowMutiFingers", _g_get_allowMutiFingers); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "allowOutOfRange", _g_get_allowOutOfRange); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "longHitTime", _g_get_longHitTime); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "OnEvent", _s_set_OnEvent); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "OnSelectGesture", _s_set_OnSelectGesture); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "allowMutiFingers", _s_set_allowMutiFingers); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "allowOutOfRange", _s_set_allowOutOfRange); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "longHitTime", _s_set_longHitTime); + + + 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.BFTouchSelectable(); + 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.BFTouchSelectable constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_OnEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchSelectable gen_to_be_invoked = (BF.BFTouchSelectable)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.OnEvent); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_OnSelectGesture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchSelectable gen_to_be_invoked = (BF.BFTouchSelectable)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.OnSelectGesture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsSelected(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchSelectable gen_to_be_invoked = (BF.BFTouchSelectable)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsSelected); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsLongSelected(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchSelectable gen_to_be_invoked = (BF.BFTouchSelectable)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsLongSelected); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_allowMutiFingers(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchSelectable gen_to_be_invoked = (BF.BFTouchSelectable)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.allowMutiFingers); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_allowOutOfRange(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchSelectable gen_to_be_invoked = (BF.BFTouchSelectable)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.allowOutOfRange); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_longHitTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchSelectable gen_to_be_invoked = (BF.BFTouchSelectable)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.longHitTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_OnEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchSelectable gen_to_be_invoked = (BF.BFTouchSelectable)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.OnEvent = (BF.BFEvent)translator.GetObject(L, 2, typeof(BF.BFEvent)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_OnSelectGesture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchSelectable gen_to_be_invoked = (BF.BFTouchSelectable)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.OnSelectGesture = (BF.BFEvent>)translator.GetObject(L, 2, typeof(BF.BFEvent>)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_allowMutiFingers(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchSelectable gen_to_be_invoked = (BF.BFTouchSelectable)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.allowMutiFingers = 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_allowOutOfRange(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchSelectable gen_to_be_invoked = (BF.BFTouchSelectable)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.allowOutOfRange = 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_longHitTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFTouchSelectable gen_to_be_invoked = (BF.BFTouchSelectable)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.longHitTime = (float)LuaAPI.lua_tonumber(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_BFUMPManagerWrap.cs b/Assets/XLua/Gen/BF_BFUMPManagerWrap.cs new file mode 100644 index 000000000..d070a2044 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFUMPManagerWrap.cs @@ -0,0 +1,241 @@ +#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 BFBFUMPManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFUMPManager); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 4, 3, 3); + Utils.RegisterFunc(L, Utils.CLS_IDX, "OnUMPFinish", _m_OnUMPFinish_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "AddLuaCallback", _m_AddLuaCallback_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RemoveLuaCallback", _m_RemoveLuaCallback_xlua_st_); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "luaCallback", _g_get_luaCallback); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "IsUMPFinish", _g_get_IsUMPFinish); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "UMPState", _g_get_UMPState); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "luaCallback", _s_set_luaCallback); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "IsUMPFinish", _s_set_IsUMPFinish); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "UMPState", _s_set_UMPState); + + + 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.BFUMPManager(); + 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.BFUMPManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnUMPFinish_xlua_st_(RealStatePtr L) + { + try { + + + + + { + int _state = LuaAPI.xlua_tointeger(L, 1); + + BF.BFUMPManager.OnUMPFinish( _state ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddLuaCallback_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.Action _callback = translator.GetDelegate(L, 1); + + BF.BFUMPManager.AddLuaCallback( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveLuaCallback_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + BF.BFUMPManager.RemoveLuaCallback( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, BF.BFUMPManager.luaCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsUMPFinish(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, BF.BFUMPManager.IsUMPFinish); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UMPState(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, BF.BFUMPManager.UMPState); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_luaCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + BF.BFUMPManager.luaCallback = translator.GetDelegate(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_IsUMPFinish(RealStatePtr L) + { + try { + + BF.BFUMPManager.IsUMPFinish = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_UMPState(RealStatePtr L) + { + try { + + BF.BFUMPManager.UMPState = LuaAPI.xlua_tointeger(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_BFUnitySliderWrap.cs b/Assets/XLua/Gen/BF_BFUnitySliderWrap.cs new file mode 100644 index 000000000..bffd68388 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFUnitySliderWrap.cs @@ -0,0 +1,200 @@ +#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 BFBFUnitySliderWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFUnitySlider); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddOnBeginDragCallback", _m_AddOnBeginDragCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddOnEndDragCallback", _m_AddOnEndDragCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBeginDrag", _m_OnBeginDrag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnEndDrag", _m_OnEndDrag); + + + + + + 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.BFUnitySlider(); + 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.BFUnitySlider constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddOnBeginDragCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFUnitySlider gen_to_be_invoked = (BF.BFUnitySlider)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callback = translator.GetDelegate(L, 2); + + gen_to_be_invoked.AddOnBeginDragCallback( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddOnEndDragCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFUnitySlider gen_to_be_invoked = (BF.BFUnitySlider)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callback = translator.GetDelegate(L, 2); + + gen_to_be_invoked.AddOnEndDragCallback( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnBeginDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFUnitySlider gen_to_be_invoked = (BF.BFUnitySlider)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnBeginDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnEndDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFUnitySlider gen_to_be_invoked = (BF.BFUnitySlider)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnEndDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_BFVersionInfoWrap.cs b/Assets/XLua/Gen/BF_BFVersionInfoWrap.cs new file mode 100644 index 000000000..7426549f6 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFVersionInfoWrap.cs @@ -0,0 +1,394 @@ +#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 BFBFVersionInfoWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFVersionInfo); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 10, 10); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "min_version", _g_get_min_version); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "latest_version", _g_get_latest_version); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "version", _g_get_version); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "store_url", _g_get_store_url); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "env", _g_get_env); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "cdn_url", _g_get_cdn_url); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "game_urls", _g_get_game_urls); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "open_at", _g_get_open_at); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "now", _g_get_now); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "notice", _g_get_notice); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "min_version", _s_set_min_version); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "latest_version", _s_set_latest_version); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "version", _s_set_version); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "store_url", _s_set_store_url); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "env", _s_set_env); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "cdn_url", _s_set_cdn_url); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "game_urls", _s_set_game_urls); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "open_at", _s_set_open_at); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "now", _s_set_now); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "notice", _s_set_notice); + + + 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.BFVersionInfo(); + 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.BFVersionInfo constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_min_version(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFVersionInfo gen_to_be_invoked = (BF.BFVersionInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.min_version); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_latest_version(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFVersionInfo gen_to_be_invoked = (BF.BFVersionInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.latest_version); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_version(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFVersionInfo gen_to_be_invoked = (BF.BFVersionInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.version); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_store_url(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFVersionInfo gen_to_be_invoked = (BF.BFVersionInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.store_url); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_env(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFVersionInfo gen_to_be_invoked = (BF.BFVersionInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.env); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cdn_url(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFVersionInfo gen_to_be_invoked = (BF.BFVersionInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.cdn_url); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_game_urls(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFVersionInfo gen_to_be_invoked = (BF.BFVersionInfo)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.game_urls); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_open_at(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFVersionInfo gen_to_be_invoked = (BF.BFVersionInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushint64(L, gen_to_be_invoked.open_at); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_now(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFVersionInfo gen_to_be_invoked = (BF.BFVersionInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushint64(L, gen_to_be_invoked.now); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_notice(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFVersionInfo gen_to_be_invoked = (BF.BFVersionInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.notice); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_min_version(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFVersionInfo gen_to_be_invoked = (BF.BFVersionInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.min_version = 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_latest_version(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFVersionInfo gen_to_be_invoked = (BF.BFVersionInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.latest_version = 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_version(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFVersionInfo gen_to_be_invoked = (BF.BFVersionInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.version = 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_store_url(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFVersionInfo gen_to_be_invoked = (BF.BFVersionInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.store_url = 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_env(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFVersionInfo gen_to_be_invoked = (BF.BFVersionInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.env = 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_cdn_url(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFVersionInfo gen_to_be_invoked = (BF.BFVersionInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.cdn_url = 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_game_urls(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFVersionInfo gen_to_be_invoked = (BF.BFVersionInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.game_urls = (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; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_open_at(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFVersionInfo gen_to_be_invoked = (BF.BFVersionInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.open_at = 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_now(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFVersionInfo gen_to_be_invoked = (BF.BFVersionInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.now = 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_notice(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BFVersionInfo gen_to_be_invoked = (BF.BFVersionInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.notice = 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/BF_BFWebRequestManagerWrap.cs b/Assets/XLua/Gen/BF_BFWebRequestManagerWrap.cs new file mode 100644 index 000000000..43999e3c0 --- /dev/null +++ b/Assets/XLua/Gen/BF_BFWebRequestManagerWrap.cs @@ -0,0 +1,325 @@ +#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 BFBFWebRequestManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BFWebRequestManager); + Utils.BeginObjectRegister(type, L, translator, 0, 6, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMono", _m_SetMono); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CreateWebRequest", _m_CreateWebRequest); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Get", _m_Get); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Post", _m_Post); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PostForm", _m_PostForm); + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Create", _m_Create_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "BF.BFWebRequestManager does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Create_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = BF.BFWebRequestManager.Create( ); + 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_SetMono(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFWebRequestManager gen_to_be_invoked = (BF.BFWebRequestManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.MonoBehaviour _mono = (UnityEngine.MonoBehaviour)translator.GetObject(L, 2, typeof(UnityEngine.MonoBehaviour)); + + gen_to_be_invoked.SetMono( _mono ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFWebRequestManager gen_to_be_invoked = (BF.BFWebRequestManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CreateWebRequest(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFWebRequestManager gen_to_be_invoked = (BF.BFWebRequestManager)translator.FastGetCSObj(L, 1); + + + + { + string _url = LuaAPI.lua_tostring(L, 2); + string _method = LuaAPI.lua_tostring(L, 3); + int _timeout = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.CreateWebRequest( _url, _method, _timeout ); + 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_Get(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFWebRequestManager gen_to_be_invoked = (BF.BFWebRequestManager)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + string _url = LuaAPI.lua_tostring(L, 2); + System.Action _callback = translator.GetDelegate>(L, 3); + int _timeout = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.Get( _url, _callback, _timeout ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 3)) + { + string _url = LuaAPI.lua_tostring(L, 2); + System.Action _callback = translator.GetDelegate>(L, 3); + + gen_to_be_invoked.Get( _url, _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.BFWebRequestManager.Get!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Post(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFWebRequestManager gen_to_be_invoked = (BF.BFWebRequestManager)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 5&& (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)&& translator.Assignable>(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + string _url = LuaAPI.lua_tostring(L, 2); + string _fields = LuaAPI.lua_tostring(L, 3); + System.Action _callback = translator.GetDelegate>(L, 4); + int _timeout = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.Post( _url, _fields, _callback, _timeout ); + + + + return 0; + } + if(gen_param_count == 4&& (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)&& translator.Assignable>(L, 4)) + { + string _url = LuaAPI.lua_tostring(L, 2); + string _fields = LuaAPI.lua_tostring(L, 3); + System.Action _callback = translator.GetDelegate>(L, 4); + + gen_to_be_invoked.Post( _url, _fields, _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.BFWebRequestManager.Post!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PostForm(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BFWebRequestManager gen_to_be_invoked = (BF.BFWebRequestManager)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 5&& (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)&& translator.Assignable>(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + string _url = LuaAPI.lua_tostring(L, 2); + string _fields = LuaAPI.lua_tostring(L, 3); + System.Action _callback = translator.GetDelegate>(L, 4); + int _timeout = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.PostForm( _url, _fields, _callback, _timeout ); + + + + return 0; + } + if(gen_param_count == 4&& (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)&& translator.Assignable>(L, 4)) + { + string _url = LuaAPI.lua_tostring(L, 2); + string _fields = LuaAPI.lua_tostring(L, 3); + System.Action _callback = translator.GetDelegate>(L, 4); + + gen_to_be_invoked.PostForm( _url, _fields, _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.BFWebRequestManager.PostForm!"); + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_BIReportWrap.cs b/Assets/XLua/Gen/BF_BIReportWrap.cs new file mode 100644 index 000000000..3f397f128 --- /dev/null +++ b/Assets/XLua/Gen/BF_BIReportWrap.cs @@ -0,0 +1,386 @@ +#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 BFBIReportWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BIReport); + Utils.BeginObjectRegister(type, L, translator, 0, 10, 0, 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, "Update", _m_Update); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LateUpdate", _m_LateUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMono", _m_SetMono); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetUri", _m_SetUri); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasUri", _m_HasUri); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Post", _m_Post); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PostWithURL", _m_PostWithURL); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SendRequest", _m_SendRequest); + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Create", _m_Create_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "BF.BIReport does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Create_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = BF.BIReport.Create( ); + 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_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BIReport gen_to_be_invoked = (BF.BIReport)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Destroy(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BIReport gen_to_be_invoked = (BF.BIReport)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Destroy( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Update(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BIReport gen_to_be_invoked = (BF.BIReport)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Update( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LateUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BIReport gen_to_be_invoked = (BF.BIReport)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.LateUpdate( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMono(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BIReport gen_to_be_invoked = (BF.BIReport)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.MonoBehaviour _mono = (UnityEngine.MonoBehaviour)translator.GetObject(L, 2, typeof(UnityEngine.MonoBehaviour)); + + gen_to_be_invoked.SetMono( _mono ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetUri(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BIReport gen_to_be_invoked = (BF.BIReport)translator.FastGetCSObj(L, 1); + + + + { + string _uri = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SetUri( _uri ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasUri(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BIReport gen_to_be_invoked = (BF.BIReport)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.HasUri( ); + 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_Post(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BIReport gen_to_be_invoked = (BF.BIReport)translator.FastGetCSObj(L, 1); + + + + { + string _data = LuaAPI.lua_tostring(L, 2); + long _offset = LuaAPI.lua_toint64(L, 3); + System.Action _callback = translator.GetDelegate>(L, 4); + + gen_to_be_invoked.Post( _data, _offset, _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PostWithURL(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BIReport gen_to_be_invoked = (BF.BIReport)translator.FastGetCSObj(L, 1); + + + + { + string _url = LuaAPI.lua_tostring(L, 2); + string _data = LuaAPI.lua_tostring(L, 3); + System.Action _callback = translator.GetDelegate>(L, 4); + + gen_to_be_invoked.PostWithURL( _url, _data, _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SendRequest(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BIReport gen_to_be_invoked = (BF.BIReport)translator.FastGetCSObj(L, 1); + + + + { + string _url = LuaAPI.lua_tostring(L, 2); + string _data = LuaAPI.lua_tostring(L, 3); + System.Action _callback = translator.GetDelegate>(L, 4); + + gen_to_be_invoked.SendRequest( _url, _data, _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_BaseSortingOrderHelperWrap.cs b/Assets/XLua/Gen/BF_BaseSortingOrderHelperWrap.cs new file mode 100644 index 000000000..97347d459 --- /dev/null +++ b/Assets/XLua/Gen/BF_BaseSortingOrderHelperWrap.cs @@ -0,0 +1,157 @@ +#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 BFBaseSortingOrderHelperWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BaseSortingOrderHelper); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 1, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSortingOrder", _m_SetSortingOrder); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetUIOrder", _m_SetUIOrder); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "GroupOrder", _g_get_GroupOrder); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "GroupOrder", _s_set_GroupOrder); + + + 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, "BF.BaseSortingOrderHelper does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSortingOrder(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BaseSortingOrderHelper gen_to_be_invoked = (BF.BaseSortingOrderHelper)translator.FastGetCSObj(L, 1); + + + + { + int _uiOrder = LuaAPI.xlua_tointeger(L, 2); + int _order = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetSortingOrder( _uiOrder, _order ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetUIOrder(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BaseSortingOrderHelper gen_to_be_invoked = (BF.BaseSortingOrderHelper)translator.FastGetCSObj(L, 1); + + + + { + int _uiOrder = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetUIOrder( _uiOrder ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_GroupOrder(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BaseSortingOrderHelper gen_to_be_invoked = (BF.BaseSortingOrderHelper)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.GroupOrder); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_GroupOrder(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BaseSortingOrderHelper gen_to_be_invoked = (BF.BaseSortingOrderHelper)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.GroupOrder = 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_BattleControlBgWrap.cs b/Assets/XLua/Gen/BF_BattleControlBgWrap.cs new file mode 100644 index 000000000..842cb5365 --- /dev/null +++ b/Assets/XLua/Gen/BF_BattleControlBgWrap.cs @@ -0,0 +1,268 @@ +#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 BFBattleControlBgWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BattleControlBg); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 5, 5); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPositionByTime", _m_SetPositionByTime); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "speed", _g_get_speed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "endX", _g_get_endX); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "resetX", _g_get_resetX); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "type", _g_get_type); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "canMove", _g_get_canMove); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "speed", _s_set_speed); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "endX", _s_set_endX); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "resetX", _s_set_resetX); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "type", _s_set_type); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "canMove", _s_set_canMove); + + + 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.BattleControlBg(); + 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.BattleControlBg constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetPositionByTime(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BattleControlBg gen_to_be_invoked = (BF.BattleControlBg)translator.FastGetCSObj(L, 1); + + + + { + float _time = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.SetPositionByTime( _time ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_speed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BattleControlBg gen_to_be_invoked = (BF.BattleControlBg)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.speed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_endX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BattleControlBg gen_to_be_invoked = (BF.BattleControlBg)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.endX); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_resetX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BattleControlBg gen_to_be_invoked = (BF.BattleControlBg)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.resetX); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_type(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BattleControlBg gen_to_be_invoked = (BF.BattleControlBg)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.type); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_canMove(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BattleControlBg gen_to_be_invoked = (BF.BattleControlBg)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.canMove); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_speed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BattleControlBg gen_to_be_invoked = (BF.BattleControlBg)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.speed = (float)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_endX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BattleControlBg gen_to_be_invoked = (BF.BattleControlBg)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.endX = (float)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_resetX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BattleControlBg gen_to_be_invoked = (BF.BattleControlBg)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.resetX = (float)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_type(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BattleControlBg gen_to_be_invoked = (BF.BattleControlBg)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.type = 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_canMove(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BattleControlBg gen_to_be_invoked = (BF.BattleControlBg)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.canMove = LuaAPI.lua_toboolean(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_BattleUnitAttrWrap.cs b/Assets/XLua/Gen/BF_BattleUnitAttrWrap.cs new file mode 100644 index 000000000..ba715d170 --- /dev/null +++ b/Assets/XLua/Gen/BF_BattleUnitAttrWrap.cs @@ -0,0 +1,263 @@ +#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 BFBattleUnitAttrWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.BattleUnitAttr); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 3, 3); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "BindGetAttributeFunc", _m_BindGetAttributeFunc); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryGetAttributeFromLua", _m_TryGetAttributeFromLua); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAttribute", _m_GetAttribute); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "UnitAttribute", _g_get_UnitAttribute); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "LuaGetAttributeFunc", _g_get_LuaGetAttributeFunc); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Side", _g_get_Side); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "UnitAttribute", _s_set_UnitAttribute); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "LuaGetAttributeFunc", _s_set_LuaGetAttributeFunc); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Side", _s_set_Side); + + + 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.BattleUnitAttr(); + 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.BattleUnitAttr constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_BindGetAttributeFunc(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BattleUnitAttr gen_to_be_invoked = (BF.BattleUnitAttr)translator.FastGetCSObj(L, 1); + + + + { + System.Action _getFunc = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.BindGetAttributeFunc( _getFunc ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TryGetAttributeFromLua(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BattleUnitAttr gen_to_be_invoked = (BF.BattleUnitAttr)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.TryGetAttributeFromLua( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetAttribute(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.BattleUnitAttr gen_to_be_invoked = (BF.BattleUnitAttr)translator.FastGetCSObj(L, 1); + + + + { + string _attr = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.GetAttribute( _attr ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UnitAttribute(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BattleUnitAttr gen_to_be_invoked = (BF.BattleUnitAttr)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.UnitAttribute); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_LuaGetAttributeFunc(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BattleUnitAttr gen_to_be_invoked = (BF.BattleUnitAttr)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.LuaGetAttributeFunc); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Side(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BattleUnitAttr gen_to_be_invoked = (BF.BattleUnitAttr)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Side); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_UnitAttribute(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BattleUnitAttr gen_to_be_invoked = (BF.BattleUnitAttr)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.UnitAttribute = (BF.BattleUnitAttribute)translator.GetObject(L, 2, typeof(BF.BattleUnitAttribute)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_LuaGetAttributeFunc(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BattleUnitAttr gen_to_be_invoked = (BF.BattleUnitAttr)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.LuaGetAttributeFunc = translator.GetDelegate>(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_Side(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.BattleUnitAttr gen_to_be_invoked = (BF.BattleUnitAttr)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Side = 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_CalculateDiffProcessorWrap.cs b/Assets/XLua/Gen/BF_CalculateDiffProcessorWrap.cs new file mode 100644 index 000000000..c911c9f76 --- /dev/null +++ b/Assets/XLua/Gen/BF_CalculateDiffProcessorWrap.cs @@ -0,0 +1,142 @@ +#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 BFCalculateDiffProcessorWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.CalculateDiffProcessor); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Process", _m_Process); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Update", _m_Update); + + + + + + 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) == 2 && translator.Assignable(L, 2)) + { + BF.GameLaunchProcessorBase _nextProcessor = (BF.GameLaunchProcessorBase)translator.GetObject(L, 2, typeof(BF.GameLaunchProcessorBase)); + + var gen_ret = new BF.CalculateDiffProcessor(_nextProcessor); + 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.CalculateDiffProcessor constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Process(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CalculateDiffProcessor gen_to_be_invoked = (BF.CalculateDiffProcessor)translator.FastGetCSObj(L, 1); + + + + { + BF.LaunchRequester _lr = (BF.LaunchRequester)translator.GetObject(L, 2, typeof(BF.LaunchRequester)); + + gen_to_be_invoked.Process( _lr ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Update(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CalculateDiffProcessor gen_to_be_invoked = (BF.CalculateDiffProcessor)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Update( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_CameraHelperWrap.cs b/Assets/XLua/Gen/BF_CameraHelperWrap.cs new file mode 100644 index 000000000..615766ece --- /dev/null +++ b/Assets/XLua/Gen/BF_CameraHelperWrap.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 BFCameraHelperWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.CameraHelper); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 1, 1); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "OriginFieldOfView", _g_get_OriginFieldOfView); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "OriginFieldOfView", _s_set_OriginFieldOfView); + + + 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.CameraHelper(); + 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.CameraHelper constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_OriginFieldOfView(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CameraHelper gen_to_be_invoked = (BF.CameraHelper)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.OriginFieldOfView); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_OriginFieldOfView(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CameraHelper gen_to_be_invoked = (BF.CameraHelper)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.OriginFieldOfView = (float)LuaAPI.lua_tonumber(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_CanvasSortingOrderHelperWrap.cs b/Assets/XLua/Gen/BF_CanvasSortingOrderHelperWrap.cs new file mode 100644 index 000000000..9df7f39a4 --- /dev/null +++ b/Assets/XLua/Gen/BF_CanvasSortingOrderHelperWrap.cs @@ -0,0 +1,143 @@ +#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 BFCanvasSortingOrderHelperWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.CanvasSortingOrderHelper); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSortingOrder", _m_SetSortingOrder); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetUIOrder", _m_SetUIOrder); + + + + + + 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.CanvasSortingOrderHelper(); + 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.CanvasSortingOrderHelper constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSortingOrder(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CanvasSortingOrderHelper gen_to_be_invoked = (BF.CanvasSortingOrderHelper)translator.FastGetCSObj(L, 1); + + + + { + int _uiOrder = LuaAPI.xlua_tointeger(L, 2); + int _order = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetSortingOrder( _uiOrder, _order ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetUIOrder(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CanvasSortingOrderHelper gen_to_be_invoked = (BF.CanvasSortingOrderHelper)translator.FastGetCSObj(L, 1); + + + + { + int _uiOrder = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetUIOrder( _uiOrder ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_CellDragEventWrap.cs b/Assets/XLua/Gen/BF_CellDragEventWrap.cs new file mode 100644 index 000000000..24966c9cc --- /dev/null +++ b/Assets/XLua/Gen/BF_CellDragEventWrap.cs @@ -0,0 +1,292 @@ +#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 BFCellDragEventWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.CellDragEvent); + Utils.BeginObjectRegister(type, L, translator, 0, 6, 1, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddTouchEventListener", _m_AddTouchEventListener); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBeginDrag", _m_OnBeginDrag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnDrag", _m_OnDrag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnEndDrag", _m_OnEndDrag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsTargetDrection", _m_IsTargetDrection); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSrollRect", _m_SetSrollRect); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "slideType", _g_get_slideType); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "slideType", _s_set_slideType); + + + 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.CellDragEvent(); + 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.CellDragEvent constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddTouchEventListener(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CellDragEvent gen_to_be_invoked = (BF.CellDragEvent)translator.FastGetCSObj(L, 1); + + + + { + System.Action _func = translator.GetDelegate>(L, 2); + int _slideType = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.AddTouchEventListener( _func, _slideType ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnBeginDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CellDragEvent gen_to_be_invoked = (BF.CellDragEvent)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnBeginDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CellDragEvent gen_to_be_invoked = (BF.CellDragEvent)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnEndDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CellDragEvent gen_to_be_invoked = (BF.CellDragEvent)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnEndDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsTargetDrection(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CellDragEvent gen_to_be_invoked = (BF.CellDragEvent)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector2 _offset;translator.Get(L, 2, out _offset); + + var gen_ret = gen_to_be_invoked.IsTargetDrection( _offset ); + 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_SetSrollRect(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CellDragEvent gen_to_be_invoked = (BF.CellDragEvent)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.UI.ScrollRect _scroll = (UnityEngine.UI.ScrollRect)translator.GetObject(L, 2, typeof(UnityEngine.UI.ScrollRect)); + + gen_to_be_invoked.SetSrollRect( _scroll ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_slideType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CellDragEvent gen_to_be_invoked = (BF.CellDragEvent)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.slideType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_slideType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CellDragEvent gen_to_be_invoked = (BF.CellDragEvent)translator.FastGetCSObj(L, 1); + BF.UITouchEventType gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.slideType = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_CellObjWrap.cs b/Assets/XLua/Gen/BF_CellObjWrap.cs new file mode 100644 index 000000000..9503a9191 --- /dev/null +++ b/Assets/XLua/Gen/BF_CellObjWrap.cs @@ -0,0 +1,177 @@ +#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 BFCellObjWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.CellObj); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 3, 3); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "gameObject", _g_get_gameObject); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "index", _g_get_index); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "objectIndex", _g_get_objectIndex); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "gameObject", _s_set_gameObject); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "index", _s_set_index); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "objectIndex", _s_set_objectIndex); + + + 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.CellObj(); + 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.CellObj constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_gameObject(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CellObj gen_to_be_invoked = (BF.CellObj)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.gameObject); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_index(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CellObj gen_to_be_invoked = (BF.CellObj)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.index); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_objectIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CellObj gen_to_be_invoked = (BF.CellObj)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.objectIndex); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_gameObject(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CellObj gen_to_be_invoked = (BF.CellObj)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.gameObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_index(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CellObj gen_to_be_invoked = (BF.CellObj)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.index = 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_objectIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CellObj gen_to_be_invoked = (BF.CellObj)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.objectIndex = 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_CharacterAnimationInfoWrap.cs b/Assets/XLua/Gen/BF_CharacterAnimationInfoWrap.cs new file mode 100644 index 000000000..608d3ba4d --- /dev/null +++ b/Assets/XLua/Gen/BF_CharacterAnimationInfoWrap.cs @@ -0,0 +1,214 @@ +#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 BFCharacterAnimationInfoWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.CharacterAnimationInfo); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 4, 4); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "hashName", _g_get_hashName); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "animationName", _g_get_animationName); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "animationTime", _g_get_animationTime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "keyFrame", _g_get_keyFrame); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "hashName", _s_set_hashName); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "animationName", _s_set_animationName); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "animationTime", _s_set_animationTime); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "keyFrame", _s_set_keyFrame); + + + 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) + { + translator.Push(L, default(BF.CharacterAnimationInfo)); + 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.CharacterAnimationInfo constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_hashName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterAnimationInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushuint(L, gen_to_be_invoked.hashName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_animationName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterAnimationInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.animationName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_animationTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterAnimationInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.animationTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_keyFrame(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterAnimationInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.keyFrame); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_hashName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterAnimationInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.hashName = LuaAPI.xlua_touint(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_animationName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterAnimationInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.animationName = LuaAPI.lua_tostring(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_animationTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterAnimationInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.animationTime = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_keyFrame(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterAnimationInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.keyFrame = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_CharacterHelperWrap.cs b/Assets/XLua/Gen/BF_CharacterHelperWrap.cs new file mode 100644 index 000000000..455aaf44e --- /dev/null +++ b/Assets/XLua/Gen/BF_CharacterHelperWrap.cs @@ -0,0 +1,647 @@ +#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 BFCharacterHelperWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.CharacterHelper); + Utils.BeginObjectRegister(type, L, translator, 0, 14, 6, 3); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetModelObject", _m_GetModelObject); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetModelHashCode", _m_GetModelHashCode); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetListCount", _m_GetListCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetGameObjectByIndex", _m_GetGameObjectByIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashNameByIndex", _m_GetHashNameByIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CacheLocalPosition", _m_CacheLocalPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLocalPosition", _m_SetLocalPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CachePosition", _m_CachePosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPosition", _m_SetPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLocalEulerAngles", _m_SetLocalEulerAngles); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLocalScale", _m_SetLocalScale); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMainModelLocalPosition", _m_SetMainModelLocalPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetStateTime", _m_GetStateTime); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetStateKeyFrame", _m_GetStateKeyFrame); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PositionX", _g_get_PositionX); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PositionY", _g_get_PositionY); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PositionZ", _g_get_PositionZ); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "modelObject", _g_get_modelObject); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "objectList", _g_get_objectList); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "animationList", _g_get_animationList); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "modelObject", _s_set_modelObject); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "objectList", _s_set_objectList); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "animationList", _s_set_animationList); + + + 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.CharacterHelper(); + 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.CharacterHelper constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetModelObject(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterHelper gen_to_be_invoked = (BF.CharacterHelper)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetModelObject( ); + 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_GetModelHashCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterHelper gen_to_be_invoked = (BF.CharacterHelper)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetModelHashCode( ); + 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_GetListCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterHelper gen_to_be_invoked = (BF.CharacterHelper)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetListCount( ); + 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_GetGameObjectByIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterHelper gen_to_be_invoked = (BF.CharacterHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetGameObjectByIndex( _index ); + 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_GetHashNameByIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterHelper gen_to_be_invoked = (BF.CharacterHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetHashNameByIndex( _index ); + LuaAPI.xlua_pushuint(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_CacheLocalPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterHelper gen_to_be_invoked = (BF.CharacterHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.CacheLocalPosition( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLocalPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterHelper gen_to_be_invoked = (BF.CharacterHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + float _z = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.SetLocalPosition( _index, _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CachePosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterHelper gen_to_be_invoked = (BF.CharacterHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.CachePosition( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterHelper gen_to_be_invoked = (BF.CharacterHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + float _z = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.SetPosition( _index, _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLocalEulerAngles(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterHelper gen_to_be_invoked = (BF.CharacterHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + float _z = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.SetLocalEulerAngles( _index, _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLocalScale(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterHelper gen_to_be_invoked = (BF.CharacterHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + float _z = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.SetLocalScale( _index, _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMainModelLocalPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterHelper gen_to_be_invoked = (BF.CharacterHelper)translator.FastGetCSObj(L, 1); + + + + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.SetMainModelLocalPosition( _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetStateTime(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterHelper gen_to_be_invoked = (BF.CharacterHelper)translator.FastGetCSObj(L, 1); + + + + { + uint _index = LuaAPI.xlua_touint(L, 2); + + var gen_ret = gen_to_be_invoked.GetStateTime( _index ); + LuaAPI.lua_pushnumber(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_GetStateKeyFrame(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterHelper gen_to_be_invoked = (BF.CharacterHelper)translator.FastGetCSObj(L, 1); + + + + { + uint _hashName = LuaAPI.xlua_touint(L, 2); + int _index = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.GetStateKeyFrame( _hashName, _index ); + LuaAPI.xlua_pushuint(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_PositionX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterHelper gen_to_be_invoked = (BF.CharacterHelper)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.PositionX); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PositionY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterHelper gen_to_be_invoked = (BF.CharacterHelper)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.PositionY); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PositionZ(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterHelper gen_to_be_invoked = (BF.CharacterHelper)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.PositionZ); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_modelObject(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterHelper gen_to_be_invoked = (BF.CharacterHelper)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.modelObject); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_objectList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterHelper gen_to_be_invoked = (BF.CharacterHelper)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.objectList); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_animationList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterHelper gen_to_be_invoked = (BF.CharacterHelper)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.animationList); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_modelObject(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterHelper gen_to_be_invoked = (BF.CharacterHelper)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.modelObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_objectList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterHelper gen_to_be_invoked = (BF.CharacterHelper)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.objectList = (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; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_animationList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterHelper gen_to_be_invoked = (BF.CharacterHelper)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.animationList = (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/BF_CharacterObjectInfoWrap.cs b/Assets/XLua/Gen/BF_CharacterObjectInfoWrap.cs new file mode 100644 index 000000000..56f357b28 --- /dev/null +++ b/Assets/XLua/Gen/BF_CharacterObjectInfoWrap.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 BFCharacterObjectInfoWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.CharacterObjectInfo); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 2); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "hashName", _g_get_hashName); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "gameObject", _g_get_gameObject); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "hashName", _s_set_hashName); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "gameObject", _s_set_gameObject); + + + 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) + { + translator.Push(L, default(BF.CharacterObjectInfo)); + 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.CharacterObjectInfo constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_hashName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterObjectInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushuint(L, gen_to_be_invoked.hashName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_gameObject(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterObjectInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.gameObject); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_hashName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterObjectInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.hashName = LuaAPI.xlua_touint(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_gameObject(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterObjectInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.gameObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_CharacterSpineHelperWrap.cs b/Assets/XLua/Gen/BF_CharacterSpineHelperWrap.cs new file mode 100644 index 000000000..16a1c17f6 --- /dev/null +++ b/Assets/XLua/Gen/BF_CharacterSpineHelperWrap.cs @@ -0,0 +1,912 @@ +#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 BFCharacterSpineHelperWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.CharacterSpineHelper); + Utils.BeginObjectRegister(type, L, translator, 0, 24, 5, 2); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Reload", _m_Reload); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PlayAnimation", _m_PlayAnimation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAnimationSpeed", _m_SetAnimationSpeed); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLoop", _m_SetLoop); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSpineObject", _m_GetSpineObject); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSkeletonGraphic", _m_GetSkeletonGraphic); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetListCount", _m_GetListCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetGameObjectByIndex", _m_GetGameObjectByIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashNameByIndex", _m_GetHashNameByIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetInstanceID", _m_GetInstanceID); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CacheLocalPosition", _m_CacheLocalPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLocalPosition", _m_SetLocalPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CachePosition", _m_CachePosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CacheBonePosition", _m_CacheBonePosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPosition", _m_SetPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLocalEulerAngles", _m_SetLocalEulerAngles); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setEulerAngles", _m_setEulerAngles); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLocalScale", _m_SetLocalScale); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLocalScaleX", _m_SetLocalScaleX); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMainSpineLocalPosition", _m_SetMainSpineLocalPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAnimationDuration", _m_GetAnimationDuration); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAnimationKeyFrameTime", _m_GetAnimationKeyFrameTime); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetDefaultMix", _m_SetDefaultMix); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PlayAnimationAndPause", _m_PlayAnimationAndPause); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PositionX", _g_get_PositionX); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PositionY", _g_get_PositionY); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PositionZ", _g_get_PositionZ); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "SpineObject", _g_get_SpineObject); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ObjectList", _g_get_ObjectList); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "SpineObject", _s_set_SpineObject); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ObjectList", _s_set_ObjectList); + + + 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.CharacterSpineHelper(); + 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.CharacterSpineHelper constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Reload(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Reload( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PlayAnimation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + + + + { + string _animName = LuaAPI.lua_tostring(L, 2); + bool _loop = LuaAPI.lua_toboolean(L, 3); + bool _forceRefresh = LuaAPI.lua_toboolean(L, 4); + + gen_to_be_invoked.PlayAnimation( _animName, _loop, _forceRefresh ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAnimationSpeed(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + + + + { + float _timeScale = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.SetAnimationSpeed( _timeScale ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLoop(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + + + + { + bool _isLoop = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.SetLoop( _isLoop ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetSpineObject(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetSpineObject( ); + 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_GetSkeletonGraphic(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetSkeletonGraphic( ); + 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_GetListCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetListCount( ); + 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_GetGameObjectByIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetGameObjectByIndex( _index ); + 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_GetHashNameByIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetHashNameByIndex( _index ); + LuaAPI.xlua_pushuint(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_GetInstanceID(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetInstanceID( _index ); + 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_CacheLocalPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.CacheLocalPosition( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLocalPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + float _z = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.SetLocalPosition( _index, _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CachePosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.CachePosition( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CacheBonePosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.CacheBonePosition( _name ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + float _z = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.SetPosition( _index, _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLocalEulerAngles(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + float _z = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.SetLocalEulerAngles( _index, _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setEulerAngles(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + float _z = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.setEulerAngles( _index, _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLocalScale(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + float _z = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.SetLocalScale( _index, _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLocalScaleX(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetLocalScaleX( _index, _x ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMainSpineLocalPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + + + + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.SetMainSpineLocalPosition( _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetAnimationDuration(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetAnimationDuration( _name ); + LuaAPI.lua_pushnumber(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_GetAnimationKeyFrameTime(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetAnimationKeyFrameTime( _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_SetDefaultMix(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + + + + { + float _mixDuration = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.SetDefaultMix( _mixDuration ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PlayAnimationAndPause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + + + + { + string _animName = LuaAPI.lua_tostring(L, 2); + float _percent = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.PlayAnimationAndPause( _animName, _percent ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PositionX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.PositionX); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PositionY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.PositionY); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PositionZ(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.PositionZ); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_SpineObject(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.SpineObject); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ObjectList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.ObjectList); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_SpineObject(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.SpineObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_ObjectList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterSpineHelper gen_to_be_invoked = (BF.CharacterSpineHelper)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ObjectList = (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/BF_CharacterSpineObjectInfoWrap.cs b/Assets/XLua/Gen/BF_CharacterSpineObjectInfoWrap.cs new file mode 100644 index 000000000..b512b65f3 --- /dev/null +++ b/Assets/XLua/Gen/BF_CharacterSpineObjectInfoWrap.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 BFCharacterSpineObjectInfoWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.CharacterSpineObjectInfo); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 2); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "hashName", _g_get_hashName); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "gameObject", _g_get_gameObject); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "hashName", _s_set_hashName); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "gameObject", _s_set_gameObject); + + + 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) + { + translator.Push(L, default(BF.CharacterSpineObjectInfo)); + 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.CharacterSpineObjectInfo constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_hashName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterSpineObjectInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushuint(L, gen_to_be_invoked.hashName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_gameObject(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterSpineObjectInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.gameObject); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_hashName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterSpineObjectInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.hashName = LuaAPI.xlua_touint(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_gameObject(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CharacterSpineObjectInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.gameObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_CombineURLWrap.cs b/Assets/XLua/Gen/BF_CombineURLWrap.cs new file mode 100644 index 000000000..e6485551a --- /dev/null +++ b/Assets/XLua/Gen/BF_CombineURLWrap.cs @@ -0,0 +1,392 @@ +#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 BFCombineURLWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.CombineURL); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 9, 9); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "cluster_type", _g_get_cluster_type); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ugate_addr", _g_get_ugate_addr); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "vsn_addr", _g_get_vsn_addr); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "upay_addr", _g_get_upay_addr); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "uchat_addr", _g_get_uchat_addr); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "community_web_addr", _g_get_community_web_addr); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "community_srv_addr", _g_get_community_srv_addr); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "aics_http_addr", _g_get_aics_http_addr); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "aics_ws_addr", _g_get_aics_ws_addr); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "cluster_type", _s_set_cluster_type); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ugate_addr", _s_set_ugate_addr); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "vsn_addr", _s_set_vsn_addr); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "upay_addr", _s_set_upay_addr); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "uchat_addr", _s_set_uchat_addr); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "community_web_addr", _s_set_community_web_addr); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "community_srv_addr", _s_set_community_srv_addr); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "aics_http_addr", _s_set_aics_http_addr); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "aics_ws_addr", _s_set_aics_ws_addr); + + + 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.CombineURL(); + 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.CombineURL constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CombineURL gen_to_be_invoked = (BF.CombineURL)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_cluster_type(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CombineURL gen_to_be_invoked = (BF.CombineURL)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.cluster_type); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ugate_addr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CombineURL gen_to_be_invoked = (BF.CombineURL)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.ugate_addr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_vsn_addr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CombineURL gen_to_be_invoked = (BF.CombineURL)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.vsn_addr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_upay_addr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CombineURL gen_to_be_invoked = (BF.CombineURL)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.upay_addr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_uchat_addr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CombineURL gen_to_be_invoked = (BF.CombineURL)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.uchat_addr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_community_web_addr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CombineURL gen_to_be_invoked = (BF.CombineURL)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.community_web_addr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_community_srv_addr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CombineURL gen_to_be_invoked = (BF.CombineURL)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.community_srv_addr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_aics_http_addr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CombineURL gen_to_be_invoked = (BF.CombineURL)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.aics_http_addr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_aics_ws_addr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CombineURL gen_to_be_invoked = (BF.CombineURL)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.aics_ws_addr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_cluster_type(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CombineURL gen_to_be_invoked = (BF.CombineURL)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.cluster_type = 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_ugate_addr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CombineURL gen_to_be_invoked = (BF.CombineURL)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ugate_addr = 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_vsn_addr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CombineURL gen_to_be_invoked = (BF.CombineURL)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.vsn_addr = 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_upay_addr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CombineURL gen_to_be_invoked = (BF.CombineURL)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.upay_addr = 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_uchat_addr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CombineURL gen_to_be_invoked = (BF.CombineURL)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.uchat_addr = 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_community_web_addr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CombineURL gen_to_be_invoked = (BF.CombineURL)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.community_web_addr = 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_community_srv_addr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CombineURL gen_to_be_invoked = (BF.CombineURL)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.community_srv_addr = 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_aics_http_addr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CombineURL gen_to_be_invoked = (BF.CombineURL)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.aics_http_addr = 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_aics_ws_addr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CombineURL gen_to_be_invoked = (BF.CombineURL)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.aics_ws_addr = 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/BF_CounterModeCryptoTransformWrap.cs b/Assets/XLua/Gen/BF_CounterModeCryptoTransformWrap.cs new file mode 100644 index 000000000..6afb0457f --- /dev/null +++ b/Assets/XLua/Gen/BF_CounterModeCryptoTransformWrap.cs @@ -0,0 +1,241 @@ +#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 BFCounterModeCryptoTransformWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.CounterModeCryptoTransform); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 4, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TransformFinalBlock", _m_TransformFinalBlock); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TransformBlock", _m_TransformBlock); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Dispose", _m_Dispose); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "InputBlockSize", _g_get_InputBlockSize); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "OutputBlockSize", _g_get_OutputBlockSize); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "CanTransformMultipleBlocks", _g_get_CanTransformMultipleBlocks); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "CanReuseTransform", _g_get_CanReuseTransform); + + + + 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) == 4 && translator.Assignable(L, 2) && (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING) && (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)) + { + System.Security.Cryptography.SymmetricAlgorithm _symmetricAlgorithm = (System.Security.Cryptography.SymmetricAlgorithm)translator.GetObject(L, 2, typeof(System.Security.Cryptography.SymmetricAlgorithm)); + byte[] _key = LuaAPI.lua_tobytes(L, 3); + byte[] _counter = LuaAPI.lua_tobytes(L, 4); + + var gen_ret = new BF.CounterModeCryptoTransform(_symmetricAlgorithm, _key, _counter); + 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.CounterModeCryptoTransform constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TransformFinalBlock(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CounterModeCryptoTransform gen_to_be_invoked = (BF.CounterModeCryptoTransform)translator.FastGetCSObj(L, 1); + + + + { + byte[] _inputBuffer = LuaAPI.lua_tobytes(L, 2); + int _inputOffset = LuaAPI.xlua_tointeger(L, 3); + int _inputCount = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.TransformFinalBlock( _inputBuffer, _inputOffset, _inputCount ); + 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 _m_TransformBlock(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CounterModeCryptoTransform gen_to_be_invoked = (BF.CounterModeCryptoTransform)translator.FastGetCSObj(L, 1); + + + + { + byte[] _inputBuffer = LuaAPI.lua_tobytes(L, 2); + int _inputOffset = LuaAPI.xlua_tointeger(L, 3); + int _inputCount = LuaAPI.xlua_tointeger(L, 4); + byte[] _outputBuffer = LuaAPI.lua_tobytes(L, 5); + int _outputOffset = LuaAPI.xlua_tointeger(L, 6); + + var gen_ret = gen_to_be_invoked.TransformBlock( _inputBuffer, _inputOffset, _inputCount, _outputBuffer, _outputOffset ); + 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_Dispose(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.CounterModeCryptoTransform gen_to_be_invoked = (BF.CounterModeCryptoTransform)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Dispose( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_InputBlockSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CounterModeCryptoTransform gen_to_be_invoked = (BF.CounterModeCryptoTransform)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.InputBlockSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_OutputBlockSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CounterModeCryptoTransform gen_to_be_invoked = (BF.CounterModeCryptoTransform)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.OutputBlockSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_CanTransformMultipleBlocks(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CounterModeCryptoTransform gen_to_be_invoked = (BF.CounterModeCryptoTransform)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.CanTransformMultipleBlocks); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_CanReuseTransform(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.CounterModeCryptoTransform gen_to_be_invoked = (BF.CounterModeCryptoTransform)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.CanReuseTransform); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} 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_DeepLinkManagerWrap.cs b/Assets/XLua/Gen/BF_DeepLinkManagerWrap.cs new file mode 100644 index 000000000..20fc49d47 --- /dev/null +++ b/Assets/XLua/Gen/BF_DeepLinkManagerWrap.cs @@ -0,0 +1,427 @@ +#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 BFDeepLinkManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.DeepLinkManager); + Utils.BeginObjectRegister(type, L, translator, 0, 6, 1, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetDeepLinkURL", _m_GetDeepLinkURL); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetDeepLinkParamsDic", _m_GetDeepLinkParamsDic); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetDeepLinkParamsJson", _m_GetDeepLinkParamsJson); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetDeepLinkValueByKey", _m_GetDeepLinkValueByKey); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLuaDeepLinkActiveCallback", _m_SetLuaDeepLinkActiveCallback); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaDeepLinkActiveCallback", _g_get_luaDeepLinkActiveCallback); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaDeepLinkActiveCallback", _s_set_luaDeepLinkActiveCallback); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 4, 5, 5); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ENTRANCE_LAN", BF.DeepLinkManager.ENTRANCE_LAN); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TRUE_FLAG", BF.DeepLinkManager.TRUE_FLAG); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FALSE_FLAG", BF.DeepLinkManager.FALSE_FLAG); + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "ENTRANCE", _g_get_ENTRANCE); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "ENV", _g_get_ENV); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "GM", _g_get_GM); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "LOG", _g_get_LOG); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "PACKAGE", _g_get_PACKAGE); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "ENTRANCE", _s_set_ENTRANCE); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "ENV", _s_set_ENV); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "GM", _s_set_GM); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "LOG", _s_set_LOG); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "PACKAGE", _s_set_PACKAGE); + + + 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.DeepLinkManager(); + 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.DeepLinkManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DeepLinkManager gen_to_be_invoked = (BF.DeepLinkManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetDeepLinkURL(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DeepLinkManager gen_to_be_invoked = (BF.DeepLinkManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetDeepLinkURL( ); + 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 _m_GetDeepLinkParamsDic(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DeepLinkManager gen_to_be_invoked = (BF.DeepLinkManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetDeepLinkParamsDic( ); + 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_GetDeepLinkParamsJson(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DeepLinkManager gen_to_be_invoked = (BF.DeepLinkManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetDeepLinkParamsJson( ); + 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 _m_GetDeepLinkValueByKey(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DeepLinkManager gen_to_be_invoked = (BF.DeepLinkManager)translator.FastGetCSObj(L, 1); + + + + { + string _key = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetDeepLinkValueByKey( _key ); + 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 _m_SetLuaDeepLinkActiveCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DeepLinkManager gen_to_be_invoked = (BF.DeepLinkManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetLuaDeepLinkActiveCallback( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ENTRANCE(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, BF.DeepLinkManager.ENTRANCE); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ENV(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, BF.DeepLinkManager.ENV); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_GM(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, BF.DeepLinkManager.GM); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_LOG(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, BF.DeepLinkManager.LOG); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PACKAGE(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, BF.DeepLinkManager.PACKAGE); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaDeepLinkActiveCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.DeepLinkManager gen_to_be_invoked = (BF.DeepLinkManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaDeepLinkActiveCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_ENTRANCE(RealStatePtr L) + { + try { + + BF.DeepLinkManager.ENTRANCE = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_ENV(RealStatePtr L) + { + try { + + BF.DeepLinkManager.ENV = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_GM(RealStatePtr L) + { + try { + + BF.DeepLinkManager.GM = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_LOG(RealStatePtr L) + { + try { + + BF.DeepLinkManager.LOG = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_PACKAGE(RealStatePtr L) + { + try { + + BF.DeepLinkManager.PACKAGE = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_luaDeepLinkActiveCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.DeepLinkManager gen_to_be_invoked = (BF.DeepLinkManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaDeepLinkActiveCallback = translator.GetDelegate>(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_DelayedWrap.cs b/Assets/XLua/Gen/BF_DelayedWrap.cs new file mode 100644 index 000000000..4981be899 --- /dev/null +++ b/Assets/XLua/Gen/BF_DelayedWrap.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 BFDelayedWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.Delayed); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 2); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "time", _g_get_time); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "action", _g_get_action); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "time", _s_set_time); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "action", _s_set_action); + + + 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) + { + translator.Push(L, default(BF.Delayed)); + 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.Delayed constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_time(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.Delayed gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.time); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_action(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.Delayed gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.action); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_time(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.Delayed gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.time = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_action(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.Delayed gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.action = translator.GetDelegate(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_DownloadUpdateProcessorWrap.cs b/Assets/XLua/Gen/BF_DownloadUpdateProcessorWrap.cs new file mode 100644 index 000000000..801f3f1d9 --- /dev/null +++ b/Assets/XLua/Gen/BF_DownloadUpdateProcessorWrap.cs @@ -0,0 +1,114 @@ +#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 BFDownloadUpdateProcessorWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.DownloadUpdateProcessor); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Process", _m_Process); + + + + + + 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) == 2 && translator.Assignable(L, 2)) + { + BF.GameLaunchProcessorBase _nextProcessor = (BF.GameLaunchProcessorBase)translator.GetObject(L, 2, typeof(BF.GameLaunchProcessorBase)); + + var gen_ret = new BF.DownloadUpdateProcessor(_nextProcessor); + 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.DownloadUpdateProcessor constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Process(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DownloadUpdateProcessor gen_to_be_invoked = (BF.DownloadUpdateProcessor)translator.FastGetCSObj(L, 1); + + + + { + BF.LaunchRequester _lr = (BF.LaunchRequester)translator.GetObject(L, 2, typeof(BF.LaunchRequester)); + + gen_to_be_invoked.Process( _lr ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_DragEventSyncWrap.cs b/Assets/XLua/Gen/BF_DragEventSyncWrap.cs new file mode 100644 index 000000000..455cd2a21 --- /dev/null +++ b/Assets/XLua/Gen/BF_DragEventSyncWrap.cs @@ -0,0 +1,202 @@ +#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 BFDragEventSyncWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.DragEventSync); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 1, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnEndDrag", _m_OnEndDrag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBeginDrag", _m_OnBeginDrag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnDrag", _m_OnDrag); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "parentScrollRect", _g_get_parentScrollRect); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "parentScrollRect", _s_set_parentScrollRect); + + + 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.DragEventSync(); + 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.DragEventSync constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnEndDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DragEventSync gen_to_be_invoked = (BF.DragEventSync)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnEndDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnBeginDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DragEventSync gen_to_be_invoked = (BF.DragEventSync)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnBeginDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DragEventSync gen_to_be_invoked = (BF.DragEventSync)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_parentScrollRect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.DragEventSync gen_to_be_invoked = (BF.DragEventSync)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.parentScrollRect); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_parentScrollRect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.DragEventSync gen_to_be_invoked = (BF.DragEventSync)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.parentScrollRect = (UnityEngine.UI.ScrollRect)translator.GetObject(L, 2, typeof(UnityEngine.UI.ScrollRect)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_DrawBezierLineWrap.cs b/Assets/XLua/Gen/BF_DrawBezierLineWrap.cs new file mode 100644 index 000000000..296213a58 --- /dev/null +++ b/Assets/XLua/Gen/BF_DrawBezierLineWrap.cs @@ -0,0 +1,447 @@ +#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 BFDrawBezierLineWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.DrawBezierLine); + Utils.BeginObjectRegister(type, L, translator, 0, 10, 1, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetStartPoint", _m_SetStartPoint); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetEndPoint", _m_SetEndPoint); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetControlPoint1", _m_SetControlPoint1); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetControlPoint2", _m_SetControlPoint2); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetDrawPointCount", _m_SetDrawPointCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DrawLine", _m_DrawLine); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearLine", _m_ClearLine); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPathList", _m_GetPathList); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetUseCubicBezier", _m_SetUseCubicBezier); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPointInCubicBezierCurve", _m_GetPointInCubicBezierCurve); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lineRender", _g_get_lineRender); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "lineRender", _s_set_lineRender); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetBezierPoint", _m_GetBezierPoint_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 BF.DrawBezierLine(); + 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.DrawBezierLine constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetStartPoint(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DrawBezierLine gen_to_be_invoked = (BF.DrawBezierLine)translator.FastGetCSObj(L, 1); + + + + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.SetStartPoint( _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetEndPoint(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DrawBezierLine gen_to_be_invoked = (BF.DrawBezierLine)translator.FastGetCSObj(L, 1); + + + + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.SetEndPoint( _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetControlPoint1(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DrawBezierLine gen_to_be_invoked = (BF.DrawBezierLine)translator.FastGetCSObj(L, 1); + + + + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.SetControlPoint1( _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetControlPoint2(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DrawBezierLine gen_to_be_invoked = (BF.DrawBezierLine)translator.FastGetCSObj(L, 1); + + + + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.SetControlPoint2( _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetDrawPointCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DrawBezierLine gen_to_be_invoked = (BF.DrawBezierLine)translator.FastGetCSObj(L, 1); + + + + { + int _count = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetDrawPointCount( _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DrawLine(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DrawBezierLine gen_to_be_invoked = (BF.DrawBezierLine)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.DrawLine( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearLine(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DrawBezierLine gen_to_be_invoked = (BF.DrawBezierLine)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearLine( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetPathList(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DrawBezierLine gen_to_be_invoked = (BF.DrawBezierLine)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetPathList( ); + 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_SetUseCubicBezier(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DrawBezierLine gen_to_be_invoked = (BF.DrawBezierLine)translator.FastGetCSObj(L, 1); + + + + { + bool _use = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.SetUseCubicBezier( _use ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetBezierPoint_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + float _t = (float)LuaAPI.lua_tonumber(L, 1); + UnityEngine.Vector3 _start;translator.Get(L, 2, out _start); + UnityEngine.Vector3 _controlPoint;translator.Get(L, 3, out _controlPoint); + UnityEngine.Vector3 _end;translator.Get(L, 4, out _end); + + var gen_ret = BF.DrawBezierLine.GetBezierPoint( _t, _start, _controlPoint, _end ); + translator.PushUnityEngineVector3(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_GetPointInCubicBezierCurve(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DrawBezierLine gen_to_be_invoked = (BF.DrawBezierLine)translator.FastGetCSObj(L, 1); + + + + { + float _t = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _startPoint;translator.Get(L, 3, out _startPoint); + UnityEngine.Vector3 _controlPoint1;translator.Get(L, 4, out _controlPoint1); + UnityEngine.Vector3 _controlPoint2;translator.Get(L, 5, out _controlPoint2); + UnityEngine.Vector3 _endPoint;translator.Get(L, 6, out _endPoint); + + var gen_ret = gen_to_be_invoked.GetPointInCubicBezierCurve( _t, _startPoint, _controlPoint1, _controlPoint2, _endPoint ); + translator.PushUnityEngineVector3(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_lineRender(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.DrawBezierLine gen_to_be_invoked = (BF.DrawBezierLine)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.lineRender); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_lineRender(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.DrawBezierLine gen_to_be_invoked = (BF.DrawBezierLine)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.lineRender = (UnityEngine.LineRenderer)translator.GetObject(L, 2, typeof(UnityEngine.LineRenderer)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_DreamlandInstancingHelperWrap.cs b/Assets/XLua/Gen/BF_DreamlandInstancingHelperWrap.cs new file mode 100644 index 000000000..eabeae3e5 --- /dev/null +++ b/Assets/XLua/Gen/BF_DreamlandInstancingHelperWrap.cs @@ -0,0 +1,310 @@ +#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 BFDreamlandInstancingHelperWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.DreamlandInstancingHelper); + Utils.BeginObjectRegister(type, L, translator, 0, 7, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLuaUpdateAction", _m_SetLuaUpdateAction); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearLuaUpdateAction", _m_ClearLuaUpdateAction); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetMaterialPorpertyBlock", _m_GetMaterialPorpertyBlock); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetMeshFilter", _m_GetMeshFilter); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CollectLightmapOffsetArray", _m_CollectLightmapOffsetArray); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CollectMaterixList", _m_CollectMaterixList); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HideChild", _m_HideChild); + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetSupportInstancing", _m_GetSupportInstancing_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 BF.DreamlandInstancingHelper(); + 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.DreamlandInstancingHelper constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLuaUpdateAction(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DreamlandInstancingHelper gen_to_be_invoked = (BF.DreamlandInstancingHelper)translator.FastGetCSObj(L, 1); + + + + { + System.Action _updateAction = translator.GetDelegate(L, 2); + + gen_to_be_invoked.SetLuaUpdateAction( _updateAction ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearLuaUpdateAction(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DreamlandInstancingHelper gen_to_be_invoked = (BF.DreamlandInstancingHelper)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearLuaUpdateAction( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetMaterialPorpertyBlock(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DreamlandInstancingHelper gen_to_be_invoked = (BF.DreamlandInstancingHelper)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetMaterialPorpertyBlock( ); + 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_GetMeshFilter(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DreamlandInstancingHelper gen_to_be_invoked = (BF.DreamlandInstancingHelper)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetMeshFilter( ); + 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_CollectLightmapOffsetArray(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DreamlandInstancingHelper gen_to_be_invoked = (BF.DreamlandInstancingHelper)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.CollectLightmapOffsetArray( ); + 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_CollectMaterixList(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DreamlandInstancingHelper gen_to_be_invoked = (BF.DreamlandInstancingHelper)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.CollectMaterixList( ); + 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_HideChild(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.DreamlandInstancingHelper gen_to_be_invoked = (BF.DreamlandInstancingHelper)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.HideChild( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetSupportInstancing_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.DreamlandInstancingHelper.GetSupportInstancing( ); + LuaAPI.lua_pushboolean(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_EffectHelperWrap.cs b/Assets/XLua/Gen/BF_EffectHelperWrap.cs new file mode 100644 index 000000000..c0bf906ff --- /dev/null +++ b/Assets/XLua/Gen/BF_EffectHelperWrap.cs @@ -0,0 +1,766 @@ +#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 BFEffectHelperWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.EffectHelper); + Utils.BeginObjectRegister(type, L, translator, 0, 18, 5, 5); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InitParticleSystemRendererList", _m_InitParticleSystemRendererList); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLocalPosition", _m_SetLocalPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPosition", _m_SetPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLocalEulerAngles", _m_SetLocalEulerAngles); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetEulerAngles", _m_SetEulerAngles); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLocalScale", _m_SetLocalScale); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSortingOrder", _m_SetSortingOrder); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetUIOrder", _m_SetUIOrder); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ChangeSortingOrderToFudge", _m_ChangeSortingOrderToFudge); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Play", _m_Play); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Stop", _m_Stop); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "StopAndClear", _m_StopAndClear); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearTrail", _m_ClearTrail); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Pause", _m_Pause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTimeScale", _m_SetTimeScale); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetParticleActive", _m_SetParticleActive); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetIsParticleActive", _m_GetIsParticleActive); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "RootParticle", _g_get_RootParticle); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "EffectDuration", _g_get_EffectDuration); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AnimatorCount", _g_get_AnimatorCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "TrailRendererCount", _g_get_TrailRendererCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "EulerAnglesFlip", _g_get_EulerAnglesFlip); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "RootParticle", _s_set_RootParticle); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "EffectDuration", _s_set_EffectDuration); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "AnimatorCount", _s_set_AnimatorCount); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "TrailRendererCount", _s_set_TrailRendererCount); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "EulerAnglesFlip", _s_set_EulerAnglesFlip); + + + 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.EffectHelper(); + 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.EffectHelper constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_InitParticleSystemRendererList(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.EffectHelper gen_to_be_invoked = (BF.EffectHelper)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.InitParticleSystemRendererList( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLocalPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.EffectHelper gen_to_be_invoked = (BF.EffectHelper)translator.FastGetCSObj(L, 1); + + + + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.SetLocalPosition( _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.EffectHelper gen_to_be_invoked = (BF.EffectHelper)translator.FastGetCSObj(L, 1); + + + + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.SetPosition( _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLocalEulerAngles(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.EffectHelper gen_to_be_invoked = (BF.EffectHelper)translator.FastGetCSObj(L, 1); + + + + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.SetLocalEulerAngles( _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetEulerAngles(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.EffectHelper gen_to_be_invoked = (BF.EffectHelper)translator.FastGetCSObj(L, 1); + + + + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.SetEulerAngles( _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLocalScale(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.EffectHelper gen_to_be_invoked = (BF.EffectHelper)translator.FastGetCSObj(L, 1); + + + + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.SetLocalScale( _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSortingOrder(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.EffectHelper gen_to_be_invoked = (BF.EffectHelper)translator.FastGetCSObj(L, 1); + + + + { + int _uiOrder = LuaAPI.xlua_tointeger(L, 2); + int _order = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetSortingOrder( _uiOrder, _order ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetUIOrder(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.EffectHelper gen_to_be_invoked = (BF.EffectHelper)translator.FastGetCSObj(L, 1); + + + + { + int _uiOrder = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetUIOrder( _uiOrder ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ChangeSortingOrderToFudge(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.EffectHelper gen_to_be_invoked = (BF.EffectHelper)translator.FastGetCSObj(L, 1); + + + + { + int _order = LuaAPI.xlua_tointeger(L, 2); + float _coefficient = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.ChangeSortingOrderToFudge( _order, _coefficient ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Play(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.EffectHelper gen_to_be_invoked = (BF.EffectHelper)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Play( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Clear(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.EffectHelper gen_to_be_invoked = (BF.EffectHelper)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Clear( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Stop(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.EffectHelper gen_to_be_invoked = (BF.EffectHelper)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Stop( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_StopAndClear(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.EffectHelper gen_to_be_invoked = (BF.EffectHelper)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.StopAndClear( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearTrail(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.EffectHelper gen_to_be_invoked = (BF.EffectHelper)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearTrail( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Pause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.EffectHelper gen_to_be_invoked = (BF.EffectHelper)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Pause( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTimeScale(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.EffectHelper gen_to_be_invoked = (BF.EffectHelper)translator.FastGetCSObj(L, 1); + + + + { + float _timeScale = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.SetTimeScale( _timeScale ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetParticleActive(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.EffectHelper gen_to_be_invoked = (BF.EffectHelper)translator.FastGetCSObj(L, 1); + + + + { + bool _active = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.SetParticleActive( _active ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetIsParticleActive(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.EffectHelper gen_to_be_invoked = (BF.EffectHelper)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetIsParticleActive( ); + 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 _g_get_RootParticle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.EffectHelper gen_to_be_invoked = (BF.EffectHelper)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.RootParticle); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_EffectDuration(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.EffectHelper gen_to_be_invoked = (BF.EffectHelper)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.EffectDuration); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AnimatorCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.EffectHelper gen_to_be_invoked = (BF.EffectHelper)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.AnimatorCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_TrailRendererCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.EffectHelper gen_to_be_invoked = (BF.EffectHelper)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.TrailRendererCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_EulerAnglesFlip(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.EffectHelper gen_to_be_invoked = (BF.EffectHelper)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.EulerAnglesFlip); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_RootParticle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.EffectHelper gen_to_be_invoked = (BF.EffectHelper)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.RootParticle = (UnityEngine.ParticleSystem)translator.GetObject(L, 2, typeof(UnityEngine.ParticleSystem)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_EffectDuration(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.EffectHelper gen_to_be_invoked = (BF.EffectHelper)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.EffectDuration = (float)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_AnimatorCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.EffectHelper gen_to_be_invoked = (BF.EffectHelper)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.AnimatorCount = 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_TrailRendererCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.EffectHelper gen_to_be_invoked = (BF.EffectHelper)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.TrailRendererCount = 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_EulerAnglesFlip(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.EffectHelper gen_to_be_invoked = (BF.EffectHelper)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.EulerAnglesFlip = LuaAPI.lua_toboolean(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_EliminationTouchEventWrap.cs b/Assets/XLua/Gen/BF_EliminationTouchEventWrap.cs new file mode 100644 index 000000000..d0a2481be --- /dev/null +++ b/Assets/XLua/Gen/BF_EliminationTouchEventWrap.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 BFEliminationTouchEventWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.EliminationTouchEvent); + Utils.BeginObjectRegister(type, L, translator, 0, 7, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddTouchEventListener", _m_AddTouchEventListener); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveEventListener", _m_RemoveEventListener); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnCancel", _m_OnCancel); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerDown", _m_OnPointerDown); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerEnter", _m_OnPointerEnter); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerExit", _m_OnPointerExit); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerUp", _m_OnPointerUp); + + + + + + 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.EliminationTouchEvent(); + 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.EliminationTouchEvent constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddTouchEventListener(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.EliminationTouchEvent gen_to_be_invoked = (BF.EliminationTouchEvent)translator.FastGetCSObj(L, 1); + + + + { + System.Action _func = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.AddTouchEventListener( _func ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveEventListener(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.EliminationTouchEvent gen_to_be_invoked = (BF.EliminationTouchEvent)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RemoveEventListener( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnCancel(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.EliminationTouchEvent gen_to_be_invoked = (BF.EliminationTouchEvent)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.BaseEventData _eventData = (UnityEngine.EventSystems.BaseEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.BaseEventData)); + + gen_to_be_invoked.OnCancel( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerDown(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.EliminationTouchEvent gen_to_be_invoked = (BF.EliminationTouchEvent)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerDown( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerEnter(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.EliminationTouchEvent gen_to_be_invoked = (BF.EliminationTouchEvent)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerEnter( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerExit(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.EliminationTouchEvent gen_to_be_invoked = (BF.EliminationTouchEvent)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerExit( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerUp(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.EliminationTouchEvent gen_to_be_invoked = (BF.EliminationTouchEvent)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerUp( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_EmojiGraphicWrap.cs b/Assets/XLua/Gen/BF_EmojiGraphicWrap.cs new file mode 100644 index 000000000..10a7f3e69 --- /dev/null +++ b/Assets/XLua/Gen/BF_EmojiGraphicWrap.cs @@ -0,0 +1,189 @@ +#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 BFEmojiGraphicWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.EmojiGraphic); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 2, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMeshInfos", _m_SetMeshInfos); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMeshInfoFromLua", _m_SetMeshInfoFromLua); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "MainTexture", _g_get_MainTexture); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mainTexture", _g_get_mainTexture); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "MainTexture", _s_set_MainTexture); + + + 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.EmojiGraphic(); + 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.EmojiGraphic constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMeshInfos(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.EmojiGraphic gen_to_be_invoked = (BF.EmojiGraphic)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.List _emojiInfos = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.SetMeshInfos( _emojiInfos ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMeshInfoFromLua(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.EmojiGraphic gen_to_be_invoked = (BF.EmojiGraphic)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.List _pos = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _uv = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.SetMeshInfoFromLua( _pos, _uv ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_MainTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.EmojiGraphic gen_to_be_invoked = (BF.EmojiGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.MainTexture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mainTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.EmojiGraphic gen_to_be_invoked = (BF.EmojiGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.mainTexture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_MainTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.EmojiGraphic gen_to_be_invoked = (BF.EmojiGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.MainTexture = (UnityEngine.Texture2D)translator.GetObject(L, 2, typeof(UnityEngine.Texture2D)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_EmojiInfoWrap.cs b/Assets/XLua/Gen/BF_EmojiInfoWrap.cs new file mode 100644 index 000000000..89a38402e --- /dev/null +++ b/Assets/XLua/Gen/BF_EmojiInfoWrap.cs @@ -0,0 +1,270 @@ +#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 BFEmojiInfoWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.EmojiInfo); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 6, 6); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "StartIndex", _g_get_StartIndex); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "StartStrIndex", _g_get_StartStrIndex); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Length", _g_get_Length); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Corner", _g_get_Corner); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "UVs", _g_get_UVs); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "StartTrueStrIndex", _g_get_StartTrueStrIndex); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "StartIndex", _s_set_StartIndex); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "StartStrIndex", _s_set_StartStrIndex); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Length", _s_set_Length); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Corner", _s_set_Corner); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "UVs", _s_set_UVs); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "StartTrueStrIndex", _s_set_StartTrueStrIndex); + + + 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.EmojiInfo(); + 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.EmojiInfo constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_StartIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.EmojiInfo gen_to_be_invoked = (BF.EmojiInfo)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.StartIndex); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_StartStrIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.EmojiInfo gen_to_be_invoked = (BF.EmojiInfo)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.StartStrIndex); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Length(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.EmojiInfo gen_to_be_invoked = (BF.EmojiInfo)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Length); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Corner(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.EmojiInfo gen_to_be_invoked = (BF.EmojiInfo)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Corner); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UVs(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.EmojiInfo gen_to_be_invoked = (BF.EmojiInfo)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.UVs); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_StartTrueStrIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.EmojiInfo gen_to_be_invoked = (BF.EmojiInfo)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.StartTrueStrIndex); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_StartIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.EmojiInfo gen_to_be_invoked = (BF.EmojiInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.StartIndex = 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_StartStrIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.EmojiInfo gen_to_be_invoked = (BF.EmojiInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.StartStrIndex = 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_Length(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.EmojiInfo gen_to_be_invoked = (BF.EmojiInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Length = 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_Corner(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.EmojiInfo gen_to_be_invoked = (BF.EmojiInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Corner = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_UVs(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.EmojiInfo gen_to_be_invoked = (BF.EmojiInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.UVs = (UnityEngine.Vector2[])translator.GetObject(L, 2, typeof(UnityEngine.Vector2[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_StartTrueStrIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.EmojiInfo gen_to_be_invoked = (BF.EmojiInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.StartTrueStrIndex = 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_EmptyRaycastWrap.cs b/Assets/XLua/Gen/BF_EmptyRaycastWrap.cs new file mode 100644 index 000000000..28774e1b3 --- /dev/null +++ b/Assets/XLua/Gen/BF_EmptyRaycastWrap.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 BFEmptyRaycastWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.EmptyRaycast); + 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, "BF.EmptyRaycast does not have a constructor!"); + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_EnumFlagsAttributeWrap.cs b/Assets/XLua/Gen/BF_EnumFlagsAttributeWrap.cs new file mode 100644 index 000000000..df875b202 --- /dev/null +++ b/Assets/XLua/Gen/BF_EnumFlagsAttributeWrap.cs @@ -0,0 +1,84 @@ +#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 BFEnumFlagsAttributeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.EnumFlagsAttribute); + 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) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new BF.EnumFlagsAttribute(); + 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.EnumFlagsAttribute constructor!"); + + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_ExtensionMethodsWrap.cs b/Assets/XLua/Gen/BF_ExtensionMethodsWrap.cs new file mode 100644 index 000000000..d41850e18 --- /dev/null +++ b/Assets/XLua/Gen/BF_ExtensionMethodsWrap.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 BFExtensionMethodsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.ExtensionMethods); + 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, "BF.ExtensionMethods does not have a constructor!"); + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_FirstABProcessorWrap.cs b/Assets/XLua/Gen/BF_FirstABProcessorWrap.cs new file mode 100644 index 000000000..af2eea30d --- /dev/null +++ b/Assets/XLua/Gen/BF_FirstABProcessorWrap.cs @@ -0,0 +1,171 @@ +#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 BFFirstABProcessorWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.FirstABProcessor); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Process", _m_Process); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetFirstAB", _m_GetFirstAB); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnloadFirstAb", _m_UnloadFirstAb); + + + + + + 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) == 2 && translator.Assignable(L, 2)) + { + BF.GameLaunchProcessorBase _nextProcessor = (BF.GameLaunchProcessorBase)translator.GetObject(L, 2, typeof(BF.GameLaunchProcessorBase)); + + var gen_ret = new BF.FirstABProcessor(_nextProcessor); + 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.FirstABProcessor constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Process(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.FirstABProcessor gen_to_be_invoked = (BF.FirstABProcessor)translator.FastGetCSObj(L, 1); + + + + { + BF.LaunchRequester _lr = (BF.LaunchRequester)translator.GetObject(L, 2, typeof(BF.LaunchRequester)); + + gen_to_be_invoked.Process( _lr ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetFirstAB(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.FirstABProcessor gen_to_be_invoked = (BF.FirstABProcessor)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetFirstAB( ); + 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_UnloadFirstAb(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.FirstABProcessor gen_to_be_invoked = (BF.FirstABProcessor)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.UnloadFirstAb( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_FixUpProcessorWrap.cs b/Assets/XLua/Gen/BF_FixUpProcessorWrap.cs new file mode 100644 index 000000000..7802661df --- /dev/null +++ b/Assets/XLua/Gen/BF_FixUpProcessorWrap.cs @@ -0,0 +1,114 @@ +#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 BFFixUpProcessorWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.FixUpProcessor); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Process", _m_Process); + + + + + + 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) == 2 && translator.Assignable(L, 2)) + { + BF.GameLaunchProcessorBase _nextProcessor = (BF.GameLaunchProcessorBase)translator.GetObject(L, 2, typeof(BF.GameLaunchProcessorBase)); + + var gen_ret = new BF.FixUpProcessor(_nextProcessor); + 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.FixUpProcessor constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Process(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.FixUpProcessor gen_to_be_invoked = (BF.FixUpProcessor)translator.FastGetCSObj(L, 1); + + + + { + BF.LaunchRequester _lr = (BF.LaunchRequester)translator.GetObject(L, 2, typeof(BF.LaunchRequester)); + + gen_to_be_invoked.Process( _lr ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_GameConstWrap.cs b/Assets/XLua/Gen/BF_GameConstWrap.cs new file mode 100644 index 000000000..579f84532 --- /dev/null +++ b/Assets/XLua/Gen/BF_GameConstWrap.cs @@ -0,0 +1,132 @@ +#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 BFGameConstWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.GameConst); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 12, 2, 2); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DESIGN_RESOLUTION_WIDTH", BF.GameConst.DESIGN_RESOLUTION_WIDTH); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DESIGN_RESOLUTION_HEIGHT", BF.GameConst.DESIGN_RESOLUTION_HEIGHT); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BIG_TEXTURE_WIDTH", BF.GameConst.BIG_TEXTURE_WIDTH); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BIG_TEXTURE_HEIGHT", BF.GameConst.BIG_TEXTURE_HEIGHT); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EDITOR_MODE", BF.GameConst.EDITOR_MODE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DEBUG", BF.GameConst.DEBUG); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "USE_AB", BF.GameConst.USE_AB); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SKIP_VERSION", BF.GameConst.SKIP_VERSION); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BF_APP_DEV", BF.GameConst.BF_APP_DEV); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BF_APP_TEST", BF.GameConst.BF_APP_TEST); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BF_APP_PUBLISH", BF.GameConst.BF_APP_PUBLISH); + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "C_FREE_CHAR", _g_get_C_FREE_CHAR); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "C_CONFIG_CHAR", _g_get_C_CONFIG_CHAR); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "C_FREE_CHAR", _s_set_C_FREE_CHAR); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "C_CONFIG_CHAR", _s_set_C_CONFIG_CHAR); + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "BF.GameConst does not have a constructor!"); + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_C_FREE_CHAR(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, BF.GameConst.C_FREE_CHAR); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_C_CONFIG_CHAR(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, BF.GameConst.C_CONFIG_CHAR); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_C_FREE_CHAR(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + BF.GameConst.C_FREE_CHAR = (char[])translator.GetObject(L, 1, typeof(char[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_C_CONFIG_CHAR(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + BF.GameConst.C_CONFIG_CHAR = (char[])translator.GetObject(L, 1, typeof(char[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_GameLaunchManagerWrap.cs b/Assets/XLua/Gen/BF_GameLaunchManagerWrap.cs new file mode 100644 index 000000000..daf9fb603 --- /dev/null +++ b/Assets/XLua/Gen/BF_GameLaunchManagerWrap.cs @@ -0,0 +1,639 @@ +#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 BFGameLaunchManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.GameLaunchManager); + Utils.BeginObjectRegister(type, L, translator, 0, 16, 3, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMono", _m_SetMono); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Update", _m_Update); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Destroy", _m_Destroy); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ShowIOSATTrack", _m_ShowIOSATTrack); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LaunchGame", _m_LaunchGame); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LaunchForLogin", _m_LaunchForLogin); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LaunchForRelogin", _m_LaunchForRelogin); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LaunchForLanguage", _m_LaunchForLanguage); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsNetworkReachability", _m_IsNetworkReachability); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsWifi", _m_IsWifi); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetCurrentProcessor", _m_SetCurrentProcessor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsVersionWhiteList", _m_IsVersionWhiteList); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetFirstAB", _m_GetFirstAB); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetCurrentVersion", _m_GetCurrentVersion); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "QuitGame", _m_QuitGame); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "LaunchRequester", _g_get_LaunchRequester); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "LaunchTimes", _g_get_LaunchTimes); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "LoadedFirstAb", _g_get_LoadedFirstAb); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "LoadedFirstAb", _s_set_LoadedFirstAb); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 3, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Create", _m_Create_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ForJustice", _m_ForJustice_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "BF.GameLaunchManager does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Create_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = BF.GameLaunchManager.Create( ); + 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_SetMono(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.GameLaunchManager gen_to_be_invoked = (BF.GameLaunchManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.MonoBehaviour _mono = (UnityEngine.MonoBehaviour)translator.GetObject(L, 2, typeof(UnityEngine.MonoBehaviour)); + + gen_to_be_invoked.SetMono( _mono ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.GameLaunchManager gen_to_be_invoked = (BF.GameLaunchManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Update(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.GameLaunchManager gen_to_be_invoked = (BF.GameLaunchManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Update( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Destroy(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.GameLaunchManager gen_to_be_invoked = (BF.GameLaunchManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Destroy( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ShowIOSATTrack(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.GameLaunchManager gen_to_be_invoked = (BF.GameLaunchManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ShowIOSATTrack( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LaunchGame(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.GameLaunchManager gen_to_be_invoked = (BF.GameLaunchManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.LaunchGame( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LaunchForLogin(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.GameLaunchManager gen_to_be_invoked = (BF.GameLaunchManager)translator.FastGetCSObj(L, 1); + + + + { + string _versionJson = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.LaunchForLogin( _versionJson ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LaunchForRelogin(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.GameLaunchManager gen_to_be_invoked = (BF.GameLaunchManager)translator.FastGetCSObj(L, 1); + + + + { + string _versionJson = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.LaunchForRelogin( _versionJson ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LaunchForLanguage(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.GameLaunchManager gen_to_be_invoked = (BF.GameLaunchManager)translator.FastGetCSObj(L, 1); + + + + { + string _language = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.LaunchForLanguage( _language ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsNetworkReachability(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.GameLaunchManager gen_to_be_invoked = (BF.GameLaunchManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsNetworkReachability( ); + 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_IsWifi(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.GameLaunchManager gen_to_be_invoked = (BF.GameLaunchManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsWifi( ); + 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_SetCurrentProcessor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.GameLaunchManager gen_to_be_invoked = (BF.GameLaunchManager)translator.FastGetCSObj(L, 1); + + + + { + BF.GameLaunchProcessorBase _processor = (BF.GameLaunchProcessorBase)translator.GetObject(L, 2, typeof(BF.GameLaunchProcessorBase)); + + gen_to_be_invoked.SetCurrentProcessor( _processor ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsVersionWhiteList(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.GameLaunchManager gen_to_be_invoked = (BF.GameLaunchManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsVersionWhiteList( ); + 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_GetFirstAB(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.GameLaunchManager gen_to_be_invoked = (BF.GameLaunchManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetFirstAB( ); + 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_GetCurrentVersion(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.GameLaunchManager gen_to_be_invoked = (BF.GameLaunchManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetCurrentVersion( ); + 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 _m_QuitGame(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.GameLaunchManager gen_to_be_invoked = (BF.GameLaunchManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.QuitGame( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ForJustice_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _str = LuaAPI.lua_tostring(L, 1); + + var gen_ret = BF.GameLaunchManager.ForJustice( _str ); + 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_LaunchRequester(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.GameLaunchManager gen_to_be_invoked = (BF.GameLaunchManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.LaunchRequester); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_LaunchTimes(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.GameLaunchManager gen_to_be_invoked = (BF.GameLaunchManager)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.LaunchTimes); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_LoadedFirstAb(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.GameLaunchManager gen_to_be_invoked = (BF.GameLaunchManager)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.LoadedFirstAb); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_LoadedFirstAb(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.GameLaunchManager gen_to_be_invoked = (BF.GameLaunchManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.LoadedFirstAb = LuaAPI.lua_toboolean(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_GameLaunchProcessorBaseWrap.cs b/Assets/XLua/Gen/BF_GameLaunchProcessorBaseWrap.cs new file mode 100644 index 000000000..46ea7145c --- /dev/null +++ b/Assets/XLua/Gen/BF_GameLaunchProcessorBaseWrap.cs @@ -0,0 +1,217 @@ +#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 BFGameLaunchProcessorBaseWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.GameLaunchProcessorBase); + Utils.BeginObjectRegister(type, L, translator, 0, 5, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Process", _m_Process); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Update", _m_Update); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsPersistentLessThanPackageVersion", _m_IsPersistentLessThanPackageVersion); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsClientBiggerThanMinVersion", _m_IsClientBiggerThanMinVersion); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsClientBiggerThanLatestVersion", _m_IsClientBiggerThanLatestVersion); + + + + + + 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, "BF.GameLaunchProcessorBase does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Process(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.GameLaunchProcessorBase gen_to_be_invoked = (BF.GameLaunchProcessorBase)translator.FastGetCSObj(L, 1); + + + + { + BF.LaunchRequester _lr = (BF.LaunchRequester)translator.GetObject(L, 2, typeof(BF.LaunchRequester)); + + gen_to_be_invoked.Process( _lr ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Update(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.GameLaunchProcessorBase gen_to_be_invoked = (BF.GameLaunchProcessorBase)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Update( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsPersistentLessThanPackageVersion(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.GameLaunchProcessorBase gen_to_be_invoked = (BF.GameLaunchProcessorBase)translator.FastGetCSObj(L, 1); + + + + { + string _packageVersion = LuaAPI.lua_tostring(L, 2); + string _persistentVersion = LuaAPI.lua_tostring(L, 3); + + var gen_ret = gen_to_be_invoked.IsPersistentLessThanPackageVersion( _packageVersion, _persistentVersion ); + 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_IsClientBiggerThanMinVersion(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.GameLaunchProcessorBase gen_to_be_invoked = (BF.GameLaunchProcessorBase)translator.FastGetCSObj(L, 1); + + + + { + string _minVersion = LuaAPI.lua_tostring(L, 2); + string _clientVersion = LuaAPI.lua_tostring(L, 3); + + var gen_ret = gen_to_be_invoked.IsClientBiggerThanMinVersion( _minVersion, _clientVersion ); + 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_IsClientBiggerThanLatestVersion(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.GameLaunchProcessorBase gen_to_be_invoked = (BF.GameLaunchProcessorBase)translator.FastGetCSObj(L, 1); + + + + { + string _latestVersion = LuaAPI.lua_tostring(L, 2); + string _clientVersion = LuaAPI.lua_tostring(L, 3); + + var gen_ret = gen_to_be_invoked.IsClientBiggerThanLatestVersion( _latestVersion, _clientVersion ); + LuaAPI.lua_pushboolean(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_GameLaunchUtilsWrap.cs b/Assets/XLua/Gen/BF_GameLaunchUtilsWrap.cs new file mode 100644 index 000000000..5e4357d96 --- /dev/null +++ b/Assets/XLua/Gen/BF_GameLaunchUtilsWrap.cs @@ -0,0 +1,109 @@ +#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 BFGameLaunchUtilsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.GameLaunchUtils); + 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, "GetFileMD5", _m_GetFileMD5_xlua_st_); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ABCONFIG_FILE_NAME", BF.GameLaunchUtils.ABCONFIG_FILE_NAME); + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "BF.GameLaunchUtils does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetFileMD5_xlua_st_(RealStatePtr L) + { + try { + + + + 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 _filePath = LuaAPI.lua_tostring(L, 1); + + var gen_ret = BF.GameLaunchUtils.GetFileMD5( _filePath ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + byte[] _content = LuaAPI.lua_tobytes(L, 1); + + var gen_ret = BF.GameLaunchUtils.GetFileMD5( _content ); + LuaAPI.lua_pushstring(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.GameLaunchUtils.GetFileMD5!"); + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_GameObjectInfoWrap.cs b/Assets/XLua/Gen/BF_GameObjectInfoWrap.cs new file mode 100644 index 000000000..83bcddd11 --- /dev/null +++ b/Assets/XLua/Gen/BF_GameObjectInfoWrap.cs @@ -0,0 +1,214 @@ +#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 BFGameObjectInfoWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.GameObjectInfo); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 4, 4); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "name", _g_get_name); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "hashName", _g_get_hashName); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "objectType", _g_get_objectType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "gameObject", _g_get_gameObject); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "name", _s_set_name); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "hashName", _s_set_hashName); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "objectType", _s_set_objectType); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "gameObject", _s_set_gameObject); + + + 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) + { + translator.Push(L, default(BF.GameObjectInfo)); + 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.GameObjectInfo constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_name(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.GameObjectInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + 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_hashName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.GameObjectInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushuint(L, gen_to_be_invoked.hashName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_objectType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.GameObjectInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.objectType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_gameObject(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.GameObjectInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.gameObject); + } 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); + + BF.GameObjectInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.name = LuaAPI.lua_tostring(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_hashName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.GameObjectInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.hashName = LuaAPI.xlua_touint(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_objectType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.GameObjectInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.objectType = LuaAPI.xlua_tointeger(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_gameObject(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.GameObjectInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.gameObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_GameObjectPoolWrap.cs b/Assets/XLua/Gen/BF_GameObjectPoolWrap.cs new file mode 100644 index 000000000..7d16a0391 --- /dev/null +++ b/Assets/XLua/Gen/BF_GameObjectPoolWrap.cs @@ -0,0 +1,172 @@ +#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 BFGameObjectPoolWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.GameObjectPool); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Get", _m_Get); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Release", _m_Release); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear); + + + + + + 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.GameObjectPool(); + 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.GameObjectPool constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Get(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.GameObjectPool gen_to_be_invoked = (BF.GameObjectPool)translator.FastGetCSObj(L, 1); + + + + { + string _resPath = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.Get( _resPath ); + 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_Release(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.GameObjectPool gen_to_be_invoked = (BF.GameObjectPool)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.GameObject _gameObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + string _resPath = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.Release( _gameObject, _resPath ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Clear(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.GameObjectPool gen_to_be_invoked = (BF.GameObjectPool)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Clear( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_GlobalHelperWrap.cs b/Assets/XLua/Gen/BF_GlobalHelperWrap.cs new file mode 100644 index 000000000..0a9830e49 --- /dev/null +++ b/Assets/XLua/Gen/BF_GlobalHelperWrap.cs @@ -0,0 +1,204 @@ +#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 BFGlobalHelperWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.GlobalHelper); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 1, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetListCount", _m_GetListCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetGlobalByIndex", _m_GetGlobalByIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetText", _m_SetText); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "globalInfoList", _g_get_globalInfoList); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "globalInfoList", _s_set_globalInfoList); + + + 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.GlobalHelper(); + 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.GlobalHelper constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetListCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.GlobalHelper gen_to_be_invoked = (BF.GlobalHelper)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetListCount( ); + 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_GetGlobalByIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.GlobalHelper gen_to_be_invoked = (BF.GlobalHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetGlobalByIndex( _index ); + 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 _m_SetText(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.GlobalHelper gen_to_be_invoked = (BF.GlobalHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + string _v = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.SetText( _index, _v ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_globalInfoList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.GlobalHelper gen_to_be_invoked = (BF.GlobalHelper)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.globalInfoList); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_globalInfoList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.GlobalHelper gen_to_be_invoked = (BF.GlobalHelper)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.globalInfoList = (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/BF_GlobalInfoWrap.cs b/Assets/XLua/Gen/BF_GlobalInfoWrap.cs new file mode 100644 index 000000000..84703ef00 --- /dev/null +++ b/Assets/XLua/Gen/BF_GlobalInfoWrap.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 BFGlobalInfoWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.GlobalInfo); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 2); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "tx", _g_get_tx); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "key", _g_get_key); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "tx", _s_set_tx); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "key", _s_set_key); + + + 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) + { + translator.Push(L, default(BF.GlobalInfo)); + 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.GlobalInfo constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_tx(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.GlobalInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.tx); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_key(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.GlobalInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.key); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_tx(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.GlobalInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.tx = (TMPro.TextMeshProUGUI)translator.GetObject(L, 2, typeof(TMPro.TextMeshProUGUI)); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_key(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.GlobalInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.key = LuaAPI.lua_tostring(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_HorizontalScrollRectOldWrap.cs b/Assets/XLua/Gen/BF_HorizontalScrollRectOldWrap.cs new file mode 100644 index 000000000..c8246f5f1 --- /dev/null +++ b/Assets/XLua/Gen/BF_HorizontalScrollRectOldWrap.cs @@ -0,0 +1,141 @@ +#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 BFHorizontalScrollRectOldWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.HorizontalScrollRectOld); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshRealShowIndex", _m_RefreshRealShowIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsNotFull", _m_IsNotFull); + + + + + + 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.HorizontalScrollRectOld(); + 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.HorizontalScrollRectOld constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RefreshRealShowIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.HorizontalScrollRectOld gen_to_be_invoked = (BF.HorizontalScrollRectOld)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RefreshRealShowIndex( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsNotFull(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.HorizontalScrollRectOld gen_to_be_invoked = (BF.HorizontalScrollRectOld)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsNotFull( ); + LuaAPI.lua_pushboolean(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_HrefInfoWrap.cs b/Assets/XLua/Gen/BF_HrefInfoWrap.cs new file mode 100644 index 000000000..1388785b4 --- /dev/null +++ b/Assets/XLua/Gen/BF_HrefInfoWrap.cs @@ -0,0 +1,254 @@ +#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 BFHrefInfoWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.HrefInfo); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 6, 5); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Id", _g_get_Id); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "StartIndex", _g_get_StartIndex); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "EndIndex", _g_get_EndIndex); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Name", _g_get_Name); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "HrefValue", _g_get_HrefValue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Boxes", _g_get_Boxes); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Id", _s_set_Id); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "StartIndex", _s_set_StartIndex); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "EndIndex", _s_set_EndIndex); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Name", _s_set_Name); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "HrefValue", _s_set_HrefValue); + + + 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.HrefInfo(); + 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.HrefInfo constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Id(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.HrefInfo gen_to_be_invoked = (BF.HrefInfo)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Id); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_StartIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.HrefInfo gen_to_be_invoked = (BF.HrefInfo)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.StartIndex); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_EndIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.HrefInfo gen_to_be_invoked = (BF.HrefInfo)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.EndIndex); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Name(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.HrefInfo gen_to_be_invoked = (BF.HrefInfo)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_HrefValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.HrefInfo gen_to_be_invoked = (BF.HrefInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.HrefValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Boxes(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.HrefInfo gen_to_be_invoked = (BF.HrefInfo)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Boxes); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Id(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.HrefInfo gen_to_be_invoked = (BF.HrefInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Id = 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_StartIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.HrefInfo gen_to_be_invoked = (BF.HrefInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.StartIndex = 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_EndIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.HrefInfo gen_to_be_invoked = (BF.HrefInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.EndIndex = 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_Name(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.HrefInfo gen_to_be_invoked = (BF.HrefInfo)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_HrefValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.HrefInfo gen_to_be_invoked = (BF.HrefInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.HrefValue = 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/BF_InlineTextWrap.cs b/Assets/XLua/Gen/BF_InlineTextWrap.cs new file mode 100644 index 000000000..2ecb364ec --- /dev/null +++ b/Assets/XLua/Gen/BF_InlineTextWrap.cs @@ -0,0 +1,470 @@ +#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 BFInlineTextWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.InlineText); + Utils.BeginObjectRegister(type, L, translator, 0, 10, 4, 2); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerClick", _m_OnPointerClick); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTrueLength", _m_GetTrueLength); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetEmojiSize", _m_SetEmojiSize); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FilterStr", _m_FilterStr); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsOnlyEmoji", _m_IsOnlyEmoji); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTranslateStr", _m_GetTranslateStr); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddLuaGetEmojiUVs", _m_AddLuaGetEmojiUVs); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddLuaSetMainTexture", _m_AddLuaSetMainTexture); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddLuaGetNotCalVerticeStr", _m_AddLuaGetNotCalVerticeStr); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMainTexture", _m_SetMainTexture); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "text", _g_get_text); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preferredWidth", _g_get_preferredWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preferredHeight", _g_get_preferredHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "OnHrefClick", _g_get_OnHrefClick); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "text", _s_set_text); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "OnHrefClick", _s_set_OnHrefClick); + + + 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.InlineText(); + 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.InlineText constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerClick(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.InlineText gen_to_be_invoked = (BF.InlineText)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerClick( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetTrueLength(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.InlineText gen_to_be_invoked = (BF.InlineText)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetTrueLength( ); + 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_SetEmojiSize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.InlineText gen_to_be_invoked = (BF.InlineText)translator.FastGetCSObj(L, 1); + + + + { + int _size = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetEmojiSize( _size ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FilterStr(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.InlineText gen_to_be_invoked = (BF.InlineText)translator.FastGetCSObj(L, 1); + + + + { + int _length = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.FilterStr( _length ); + 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 _m_IsOnlyEmoji(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.InlineText gen_to_be_invoked = (BF.InlineText)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsOnlyEmoji( ); + 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_GetTranslateStr(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.InlineText gen_to_be_invoked = (BF.InlineText)translator.FastGetCSObj(L, 1); + + + + { + string _format; + + var gen_ret = gen_to_be_invoked.GetTranslateStr( out _format ); + translator.Push(L, gen_ret); + LuaAPI.lua_pushstring(L, _format); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddLuaGetEmojiUVs(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.InlineText gen_to_be_invoked = (BF.InlineText)translator.FastGetCSObj(L, 1); + + + + { + System.Func> _callback = translator.GetDelegate>>(L, 2); + + gen_to_be_invoked.AddLuaGetEmojiUVs( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddLuaSetMainTexture(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.InlineText gen_to_be_invoked = (BF.InlineText)translator.FastGetCSObj(L, 1); + + + + { + System.Func _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.AddLuaSetMainTexture( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddLuaGetNotCalVerticeStr(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.InlineText gen_to_be_invoked = (BF.InlineText)translator.FastGetCSObj(L, 1); + + + + { + System.Func> _callback = translator.GetDelegate>>(L, 2); + + gen_to_be_invoked.AddLuaGetNotCalVerticeStr( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMainTexture(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.InlineText gen_to_be_invoked = (BF.InlineText)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Texture2D _texture = (UnityEngine.Texture2D)translator.GetObject(L, 2, typeof(UnityEngine.Texture2D)); + + gen_to_be_invoked.SetMainTexture( _texture ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_text(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.InlineText gen_to_be_invoked = (BF.InlineText)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.text); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preferredWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.InlineText gen_to_be_invoked = (BF.InlineText)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.preferredWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preferredHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.InlineText gen_to_be_invoked = (BF.InlineText)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.preferredHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_OnHrefClick(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.InlineText gen_to_be_invoked = (BF.InlineText)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.OnHrefClick); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_text(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.InlineText gen_to_be_invoked = (BF.InlineText)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.text = 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_OnHrefClick(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.InlineText gen_to_be_invoked = (BF.InlineText)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.OnHrefClick = (BF.BFEvent)translator.GetObject(L, 2, typeof(BF.BFEvent)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_LanguageConfigWrap.cs b/Assets/XLua/Gen/BF_LanguageConfigWrap.cs new file mode 100644 index 000000000..2b2c659ef --- /dev/null +++ b/Assets/XLua/Gen/BF_LanguageConfigWrap.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 BFLanguageConfigWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.LanguageConfig); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 2, 2); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddAssetBundleConfig", _m_AddAssetBundleConfig); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "languageName", _g_get_languageName); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "configs", _g_get_configs); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "languageName", _s_set_languageName); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "configs", _s_set_configs); + + + 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.LanguageConfig(); + 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.LanguageConfig constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddAssetBundleConfig(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LanguageConfig gen_to_be_invoked = (BF.LanguageConfig)translator.FastGetCSObj(L, 1); + + + + { + BF.AssetBundleConfig _cfg = (BF.AssetBundleConfig)translator.GetObject(L, 2, typeof(BF.AssetBundleConfig)); + + gen_to_be_invoked.AddAssetBundleConfig( _cfg ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_languageName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LanguageConfig gen_to_be_invoked = (BF.LanguageConfig)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.languageName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_configs(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LanguageConfig gen_to_be_invoked = (BF.LanguageConfig)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.configs); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_languageName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LanguageConfig gen_to_be_invoked = (BF.LanguageConfig)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.languageName = 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_configs(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LanguageConfig gen_to_be_invoked = (BF.LanguageConfig)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.configs = (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/BF_LaunchRequesterWrap.cs b/Assets/XLua/Gen/BF_LaunchRequesterWrap.cs new file mode 100644 index 000000000..c840af17e --- /dev/null +++ b/Assets/XLua/Gen/BF_LaunchRequesterWrap.cs @@ -0,0 +1,1320 @@ +#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 BFLaunchRequesterWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.LaunchRequester); + Utils.BeginObjectRegister(type, L, translator, 0, 14, 32, 22); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLanguageName", _m_SetLanguageName); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetFirstRequestAction", _m_SetFirstRequestAction); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetVersionInfo", _m_SetVersionInfo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetShowDialogAction", _m_SetShowDialogAction); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetShowDialogComplexAction", _m_SetShowDialogComplexAction); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetHideDialogAction", _m_SetHideDialogAction); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetUpdateSliderAction", _m_SetUpdateSliderAction); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetHideSliderAction", _m_SetHideSliderAction); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPreCheckEndCallback", _m_SetPreCheckEndCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetGetTotalLengthCallback", _m_SetGetTotalLengthCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetDownloadingCallback", _m_SetDownloadingCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddLaunchSuccCallback", _m_AddLaunchSuccCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearLaunchSuccCallback", _m_ClearLaunchSuccCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PreCheckNextProcess", _m_PreCheckNextProcess); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "FirstRequestAction", _g_get_FirstRequestAction); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "DialogAction", _g_get_DialogAction); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "DialogComplexAction", _g_get_DialogComplexAction); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "HideDialogAction", _g_get_HideDialogAction); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "UpdateSilderAction", _g_get_UpdateSilderAction); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "HideSliderAction", _g_get_HideSliderAction); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "OnPreCheckEnd", _g_get_OnPreCheckEnd); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "OnGetTotalLength", _g_get_OnGetTotalLength); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "OnDownloading", _g_get_OnDownloading); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "OnLaunchSucc", _g_get_OnLaunchSucc); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isNewPackage", _g_get_isNewPackage); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isHotUpdate", _g_get_isHotUpdate); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isAutoRepair", _g_get_isAutoRepair); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "firstAb", _g_get_firstAb); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "languageName", _g_get_languageName); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "downloadLanguage", _g_get_downloadLanguage); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "persistentAbccVersion", _g_get_persistentAbccVersion); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "curVersionTempDir", _g_get_curVersionTempDir); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "versionInfo", _g_get_versionInfo); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "firstChoiceCDN", _g_get_firstChoiceCDN); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "backupCDN", _g_get_backupCDN); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "launchSucceed", _g_get_launchSucceed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "streamingAbcc", _g_get_streamingAbcc); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "persistentAbcc", _g_get_persistentAbcc); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "versionAbcc", _g_get_versionAbcc); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "streamingData", _g_get_streamingData); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "versionData", _g_get_versionData); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preCheckMissingList", _g_get_preCheckMissingList); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preCheckOverList", _g_get_preCheckOverList); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "downloadList", _g_get_downloadList); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "deleteList", _g_get_deleteList); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preCheckNextProcessAction", _g_get_preCheckNextProcessAction); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "isNewPackage", _s_set_isNewPackage); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "isHotUpdate", _s_set_isHotUpdate); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "isAutoRepair", _s_set_isAutoRepair); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "firstAb", _s_set_firstAb); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "languageName", _s_set_languageName); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "downloadLanguage", _s_set_downloadLanguage); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "persistentAbccVersion", _s_set_persistentAbccVersion); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "curVersionTempDir", _s_set_curVersionTempDir); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "versionInfo", _s_set_versionInfo); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "firstChoiceCDN", _s_set_firstChoiceCDN); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "backupCDN", _s_set_backupCDN); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "launchSucceed", _s_set_launchSucceed); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "streamingAbcc", _s_set_streamingAbcc); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "persistentAbcc", _s_set_persistentAbcc); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "versionAbcc", _s_set_versionAbcc); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "streamingData", _s_set_streamingData); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "versionData", _s_set_versionData); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "preCheckMissingList", _s_set_preCheckMissingList); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "preCheckOverList", _s_set_preCheckOverList); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "downloadList", _s_set_downloadList); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "deleteList", _s_set_deleteList); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "preCheckNextProcessAction", _s_set_preCheckNextProcessAction); + + + 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.LaunchRequester(); + 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.LaunchRequester constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLanguageName(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + + + + { + string _languageName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SetLanguageName( _languageName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetFirstRequestAction(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + + + + { + System.Action> _action = translator.GetDelegate>>(L, 2); + + gen_to_be_invoked.SetFirstRequestAction( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetVersionInfo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + + + + { + string _json = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SetVersionInfo( _json ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetShowDialogAction(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetShowDialogAction( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetShowDialogComplexAction(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetShowDialogComplexAction( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetHideDialogAction(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate(L, 2); + + gen_to_be_invoked.SetHideDialogAction( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetUpdateSliderAction(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetUpdateSliderAction( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetHideSliderAction(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate(L, 2); + + gen_to_be_invoked.SetHideSliderAction( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetPreCheckEndCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate(L, 2); + + gen_to_be_invoked.SetPreCheckEndCallback( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetGetTotalLengthCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetGetTotalLengthCallback( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetDownloadingCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetDownloadingCallback( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddLaunchSuccCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate(L, 2); + + gen_to_be_invoked.AddLaunchSuccCallback( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearLaunchSuccCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearLaunchSuccCallback( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PreCheckNextProcess(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.PreCheckNextProcess( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_FirstRequestAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.FirstRequestAction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DialogAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.DialogAction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DialogComplexAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.DialogComplexAction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_HideDialogAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.HideDialogAction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UpdateSilderAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.UpdateSilderAction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_HideSliderAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.HideSliderAction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_OnPreCheckEnd(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.OnPreCheckEnd); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_OnGetTotalLength(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.OnGetTotalLength); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_OnDownloading(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.OnDownloading); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_OnLaunchSucc(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.OnLaunchSucc); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isNewPackage(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isNewPackage); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isHotUpdate(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isHotUpdate); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isAutoRepair(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isAutoRepair); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_firstAb(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.firstAb); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_languageName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.languageName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_downloadLanguage(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.downloadLanguage); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_persistentAbccVersion(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.persistentAbccVersion); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_curVersionTempDir(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.curVersionTempDir); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_versionInfo(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.versionInfo); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_firstChoiceCDN(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.firstChoiceCDN); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_backupCDN(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.backupCDN); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_launchSucceed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.launchSucceed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_streamingAbcc(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.streamingAbcc); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_persistentAbcc(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.persistentAbcc); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_versionAbcc(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.versionAbcc); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_streamingData(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.streamingData); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_versionData(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.versionData); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preCheckMissingList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.preCheckMissingList); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preCheckOverList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.preCheckOverList); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_downloadList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.downloadList); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_deleteList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.deleteList); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preCheckNextProcessAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.preCheckNextProcessAction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_isNewPackage(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.isNewPackage = 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_isHotUpdate(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.isHotUpdate = 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_isAutoRepair(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.isAutoRepair = 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_firstAb(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.firstAb = (UnityEngine.AssetBundle)translator.GetObject(L, 2, typeof(UnityEngine.AssetBundle)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_languageName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.languageName = 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_downloadLanguage(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.downloadLanguage = 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_persistentAbccVersion(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.persistentAbccVersion = 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_curVersionTempDir(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.curVersionTempDir = 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_versionInfo(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.versionInfo = (BF.BFVersionInfo)translator.GetObject(L, 2, typeof(BF.BFVersionInfo)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_firstChoiceCDN(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.firstChoiceCDN = 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_backupCDN(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.backupCDN = 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_launchSucceed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.launchSucceed = 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_streamingAbcc(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.streamingAbcc = (BF.AssetBundleConfigCollection)translator.GetObject(L, 2, typeof(BF.AssetBundleConfigCollection)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_persistentAbcc(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.persistentAbcc = (BF.AssetBundleConfigCollection)translator.GetObject(L, 2, typeof(BF.AssetBundleConfigCollection)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_versionAbcc(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.versionAbcc = (BF.AssetBundleConfigCollection)translator.GetObject(L, 2, typeof(BF.AssetBundleConfigCollection)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_streamingData(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.streamingData = LuaAPI.lua_tobytes(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_versionData(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.versionData = LuaAPI.lua_tobytes(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_preCheckMissingList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.preCheckMissingList = (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; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_preCheckOverList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.preCheckOverList = (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; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_downloadList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.downloadList = (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; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_deleteList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.deleteList = (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; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_preCheckNextProcessAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LaunchRequester gen_to_be_invoked = (BF.LaunchRequester)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.preCheckNextProcessAction = translator.GetDelegate(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_LaunchSuccProcessorWrap.cs b/Assets/XLua/Gen/BF_LaunchSuccProcessorWrap.cs new file mode 100644 index 000000000..0a24a0c43 --- /dev/null +++ b/Assets/XLua/Gen/BF_LaunchSuccProcessorWrap.cs @@ -0,0 +1,113 @@ +#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 BFLaunchSuccProcessorWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.LaunchSuccProcessor); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Process", _m_Process); + + + + + + 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.LaunchSuccProcessor(); + 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.LaunchSuccProcessor constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Process(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LaunchSuccProcessor gen_to_be_invoked = (BF.LaunchSuccProcessor)translator.FastGetCSObj(L, 1); + + + + { + BF.LaunchRequester _lr = (BF.LaunchRequester)translator.GetObject(L, 2, typeof(BF.LaunchRequester)); + + gen_to_be_invoked.Process( _lr ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_LoaderBaseWrap.cs b/Assets/XLua/Gen/BF_LoaderBaseWrap.cs new file mode 100644 index 000000000..dc7398e8c --- /dev/null +++ b/Assets/XLua/Gen/BF_LoaderBaseWrap.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 BFLoaderBaseWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.LoaderBase); + Utils.BeginObjectRegister(type, L, translator, 0, 10, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadAssetAsync", _m_LoadAssetAsync); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadAssetSync", _m_LoadAssetSync); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Tick", _m_Tick); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Unload", _m_Unload); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnloadAllDelayAssets", _m_UnloadAllDelayAssets); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSceneLoadPath", _m_GetSceneLoadPath); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadSceneAsync", _m_LoadSceneAsync); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnloadScene", _m_UnloadScene); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ContainsAsset", _m_ContainsAsset); + + + + + + 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, "BF.LoaderBase does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadAssetAsync(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LoaderBase gen_to_be_invoked = (BF.LoaderBase)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + BF.AssetObject _assetObject = (BF.AssetObject)translator.GetObject(L, 2, typeof(BF.AssetObject)); + + gen_to_be_invoked.LoadAssetAsync( _assetObject ); + + + + return 0; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)&& translator.Assignable>(L, 4)) + { + string _assetPath = LuaAPI.lua_tostring(L, 2); + System.Type _type = (System.Type)translator.GetObject(L, 3, typeof(System.Type)); + System.Action _complete = translator.GetDelegate>(L, 4); + + var gen_ret = gen_to_be_invoked.LoadAssetAsync( _assetPath, _type, _complete ); + 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.LoaderBase.LoadAssetAsync!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadAssetSync(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LoaderBase gen_to_be_invoked = (BF.LoaderBase)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + BF.AssetObject _assetObject = (BF.AssetObject)translator.GetObject(L, 2, typeof(BF.AssetObject)); + + gen_to_be_invoked.LoadAssetSync( _assetObject ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _assetPath = LuaAPI.lua_tostring(L, 2); + System.Type _type = (System.Type)translator.GetObject(L, 3, typeof(System.Type)); + + var gen_ret = gen_to_be_invoked.LoadAssetSync( _assetPath, _type ); + 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.LoaderBase.LoadAssetSync!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Tick(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LoaderBase gen_to_be_invoked = (BF.LoaderBase)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Tick( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Unload(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LoaderBase gen_to_be_invoked = (BF.LoaderBase)translator.FastGetCSObj(L, 1); + + + + { + BF.AssetObject _asset = (BF.AssetObject)translator.GetObject(L, 2, typeof(BF.AssetObject)); + bool _immediately = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.Unload( _asset, _immediately ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UnloadAllDelayAssets(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LoaderBase gen_to_be_invoked = (BF.LoaderBase)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.UnloadAllDelayAssets( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetSceneLoadPath(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LoaderBase gen_to_be_invoked = (BF.LoaderBase)translator.FastGetCSObj(L, 1); + + + + { + string _assetBundlePath = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetSceneLoadPath( _assetBundlePath ); + 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 _m_LoadSceneAsync(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LoaderBase gen_to_be_invoked = (BF.LoaderBase)translator.FastGetCSObj(L, 1); + + + + { + string _assetBundlePath = LuaAPI.lua_tostring(L, 2); + System.Action _complete = translator.GetDelegate>(L, 3); + + gen_to_be_invoked.LoadSceneAsync( _assetBundlePath, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UnloadScene(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LoaderBase gen_to_be_invoked = (BF.LoaderBase)translator.FastGetCSObj(L, 1); + + + + { + string _assetBundlePath = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.UnloadScene( _assetBundlePath ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Clear(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LoaderBase gen_to_be_invoked = (BF.LoaderBase)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Clear( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ContainsAsset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LoaderBase gen_to_be_invoked = (BF.LoaderBase)translator.FastGetCSObj(L, 1); + + + + { + string _assetPath = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.ContainsAsset( _assetPath ); + LuaAPI.lua_pushboolean(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_LocalDataWrap.cs b/Assets/XLua/Gen/BF_LocalDataWrap.cs new file mode 100644 index 000000000..a213a39de --- /dev/null +++ b/Assets/XLua/Gen/BF_LocalDataWrap.cs @@ -0,0 +1,457 @@ +#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 BFLocalDataWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.LocalData); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 15, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetString", _m_SetString_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetString", _m_GetString_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetInt", _m_SetInt_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetInt", _m_GetInt_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetFloat", _m_SetFloat_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetFloat", _m_GetFloat_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "HasKey", _m_HasKey_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "DelKey", _m_DelKey_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetDeviceQualityCache", _m_SetDeviceQualityCache_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetDeviceQualityCache", _m_GetDeviceQualityCache_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetProtoPath", _m_SetProtoPath_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetProtoPath", _m_GetProtoPath_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetCurrentCanvasName", _m_SetCurrentCanvasName_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetCurrentCanvasName", _m_GetCurrentCanvasName_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 BF.LocalData(); + 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.LocalData constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetString_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _key = LuaAPI.lua_tostring(L, 1); + string _value = LuaAPI.lua_tostring(L, 2); + + BF.LocalData.SetString( _key, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetString_xlua_st_(RealStatePtr L) + { + try { + + + + 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 _key = LuaAPI.lua_tostring(L, 1); + + var gen_ret = BF.LocalData.GetString( _key ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _key = LuaAPI.lua_tostring(L, 1); + string _defaultValue = LuaAPI.lua_tostring(L, 2); + + var gen_ret = BF.LocalData.GetString( _key, _defaultValue ); + LuaAPI.lua_pushstring(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.LocalData.GetString!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetInt_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _key = LuaAPI.lua_tostring(L, 1); + int _value = LuaAPI.xlua_tointeger(L, 2); + + BF.LocalData.SetInt( _key, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetInt_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _key = LuaAPI.lua_tostring(L, 1); + + var gen_ret = BF.LocalData.GetInt( _key ); + 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_SetFloat_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _key = LuaAPI.lua_tostring(L, 1); + float _value = (float)LuaAPI.lua_tonumber(L, 2); + + BF.LocalData.SetFloat( _key, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetFloat_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _key = LuaAPI.lua_tostring(L, 1); + + var gen_ret = BF.LocalData.GetFloat( _key ); + LuaAPI.lua_pushnumber(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_HasKey_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _key = LuaAPI.lua_tostring(L, 1); + + var gen_ret = BF.LocalData.HasKey( _key ); + 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_DelKey_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _key = LuaAPI.lua_tostring(L, 1); + + BF.LocalData.DelKey( _key ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetDeviceQualityCache_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _value = LuaAPI.lua_tostring(L, 1); + + BF.LocalData.SetDeviceQualityCache( _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetDeviceQualityCache_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.LocalData.GetDeviceQualityCache( ); + 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 _m_SetProtoPath_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _value = LuaAPI.lua_tostring(L, 1); + + BF.LocalData.SetProtoPath( _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetProtoPath_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.LocalData.GetProtoPath( ); + 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 _m_SetCurrentCanvasName_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _value = LuaAPI.lua_tostring(L, 1); + + BF.LocalData.SetCurrentCanvasName( _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetCurrentCanvasName_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.LocalData.GetCurrentCanvasName( ); + 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/BF_LoomManagerWrap.cs b/Assets/XLua/Gen/BF_LoomManagerWrap.cs new file mode 100644 index 000000000..4a13fb5ce --- /dev/null +++ b/Assets/XLua/Gen/BF_LoomManagerWrap.cs @@ -0,0 +1,227 @@ +#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 BFLoomManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.LoomManager); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 1, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "QueueOnMainThread", _m_QueueOnMainThread); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RunAsync", _m_RunAsync); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Update", _m_Update); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "maxThreads", _g_get_maxThreads); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "maxThreads", _s_set_maxThreads); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Create", _m_Create_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "BF.LoomManager does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Create_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = BF.LoomManager.Create( ); + 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_QueueOnMainThread(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LoomManager gen_to_be_invoked = (BF.LoomManager)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.Action _action = translator.GetDelegate(L, 2); + + gen_to_be_invoked.QueueOnMainThread( _action ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + System.Action _action = translator.GetDelegate(L, 2); + float _time = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.QueueOnMainThread( _action, _time ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.LoomManager.QueueOnMainThread!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RunAsync(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LoomManager gen_to_be_invoked = (BF.LoomManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.RunAsync( _action ); + 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_Update(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LoomManager gen_to_be_invoked = (BF.LoomManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Update( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxThreads(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LoomManager gen_to_be_invoked = (BF.LoomManager)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.maxThreads); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_maxThreads(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LoomManager gen_to_be_invoked = (BF.LoomManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.maxThreads = 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_LuaManagerWrap.cs b/Assets/XLua/Gen/BF_LuaManagerWrap.cs new file mode 100644 index 000000000..d3fd6a974 --- /dev/null +++ b/Assets/XLua/Gen/BF_LuaManagerWrap.cs @@ -0,0 +1,552 @@ +#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 BFLuaManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.LuaManager); + Utils.BeginObjectRegister(type, L, translator, 0, 15, 1, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Update", _m_Update); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Destroy", _m_Destroy); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InitFirstLua", _m_InitFirstLua); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InitGame", _m_InitGame); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadLuaDeveloperMode", _m_LoadLuaDeveloperMode); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetGlobalLuaFunc", _m_GetGlobalLuaFunc); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnGameInitSucc", _m_OnGameInitSucc); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearCache", _m_ClearCache); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LuaEnvTick", _m_LuaEnvTick); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LuaEnvFullGC", _m_LuaEnvFullGC); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnApplicationFocus", _m_OnApplicationFocus); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnApplicationPause", _m_OnApplicationPause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnApplicationQuit", _m_OnApplicationQuit); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "DevExist", _g_get_DevExist); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "DevExist", _s_set_DevExist); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Create", _m_Create_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "BF.LuaManager does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Create_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = BF.LuaManager.Create( ); + 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_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LuaManager gen_to_be_invoked = (BF.LuaManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Update(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LuaManager gen_to_be_invoked = (BF.LuaManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Update( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Destroy(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LuaManager gen_to_be_invoked = (BF.LuaManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Destroy( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_InitFirstLua(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LuaManager gen_to_be_invoked = (BF.LuaManager)translator.FastGetCSObj(L, 1); + + + + { + XLua.LuaEnv.CustomLoader _loader = translator.GetDelegate(L, 2); + + gen_to_be_invoked.InitFirstLua( _loader ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_InitGame(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LuaManager gen_to_be_invoked = (BF.LuaManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _gameInitSuccCallback = translator.GetDelegate(L, 2); + + gen_to_be_invoked.InitGame( _gameInitSuccCallback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadLuaDeveloperMode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LuaManager gen_to_be_invoked = (BF.LuaManager)translator.FastGetCSObj(L, 1); + + + + { + string _scriptPath = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.LoadLuaDeveloperMode( _scriptPath ); + 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 _m_GetGlobalLuaFunc(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LuaManager gen_to_be_invoked = (BF.LuaManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.GetGlobalLuaFunc( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnGameInitSucc(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LuaManager gen_to_be_invoked = (BF.LuaManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.OnGameInitSucc( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearCache(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LuaManager gen_to_be_invoked = (BF.LuaManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearCache( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LuaEnvTick(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LuaManager gen_to_be_invoked = (BF.LuaManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.LuaEnvTick( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LuaEnvFullGC(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LuaManager gen_to_be_invoked = (BF.LuaManager)translator.FastGetCSObj(L, 1); + + + + { + int _count = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.LuaEnvFullGC( _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnApplicationFocus(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LuaManager gen_to_be_invoked = (BF.LuaManager)translator.FastGetCSObj(L, 1); + + + + { + bool _hasFocus = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.OnApplicationFocus( _hasFocus ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnApplicationPause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LuaManager gen_to_be_invoked = (BF.LuaManager)translator.FastGetCSObj(L, 1); + + + + { + bool _pauseStatus = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.OnApplicationPause( _pauseStatus ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnApplicationQuit(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LuaManager gen_to_be_invoked = (BF.LuaManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.OnApplicationQuit( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Clear(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.LuaManager gen_to_be_invoked = (BF.LuaManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Clear( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DevExist(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LuaManager gen_to_be_invoked = (BF.LuaManager)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.DevExist); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_DevExist(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.LuaManager gen_to_be_invoked = (BF.LuaManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.DevExist = LuaAPI.lua_toboolean(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_ManagerBaseWrap.cs b/Assets/XLua/Gen/BF_ManagerBaseWrap.cs new file mode 100644 index 000000000..1d6a9651b --- /dev/null +++ b/Assets/XLua/Gen/BF_ManagerBaseWrap.cs @@ -0,0 +1,225 @@ +#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 BFManagerBaseWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.ManagerBase); + Utils.BeginObjectRegister(type, L, translator, 0, 5, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMono", _m_SetMono); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Update", _m_Update); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LateUpdate", _m_LateUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Destroy", _m_Destroy); + + + + + + 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.ManagerBase(); + 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.ManagerBase constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMono(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ManagerBase gen_to_be_invoked = (BF.ManagerBase)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.MonoBehaviour _mono = (UnityEngine.MonoBehaviour)translator.GetObject(L, 2, typeof(UnityEngine.MonoBehaviour)); + + gen_to_be_invoked.SetMono( _mono ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ManagerBase gen_to_be_invoked = (BF.ManagerBase)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Update(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ManagerBase gen_to_be_invoked = (BF.ManagerBase)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Update( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LateUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ManagerBase gen_to_be_invoked = (BF.ManagerBase)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.LateUpdate( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Destroy(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ManagerBase gen_to_be_invoked = (BF.ManagerBase)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Destroy( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_Md5EncryptWrap.cs b/Assets/XLua/Gen/BF_Md5EncryptWrap.cs new file mode 100644 index 000000000..cae2c19cb --- /dev/null +++ b/Assets/XLua/Gen/BF_Md5EncryptWrap.cs @@ -0,0 +1,137 @@ +#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 BFMd5EncryptWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.Md5Encrypt); + 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, "Encrypt", _m_Encrypt_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "VerifyMd5Hash", _m_VerifyMd5Hash_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 BF.Md5Encrypt(); + 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.Md5Encrypt constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Encrypt_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _value = LuaAPI.lua_tostring(L, 1); + + var gen_ret = BF.Md5Encrypt.Encrypt( _value ); + 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 _m_VerifyMd5Hash_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _input = LuaAPI.lua_tostring(L, 1); + string _hash = LuaAPI.lua_tostring(L, 2); + + var gen_ret = BF.Md5Encrypt.VerifyMd5Hash( _input, _hash ); + LuaAPI.lua_pushboolean(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_MeshInfoWrap.cs b/Assets/XLua/Gen/BF_MeshInfoWrap.cs new file mode 100644 index 000000000..a2c6113b6 --- /dev/null +++ b/Assets/XLua/Gen/BF_MeshInfoWrap.cs @@ -0,0 +1,202 @@ +#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 BFMeshInfoWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.MeshInfo); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 2, 2); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Reset", _m_Reset); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Release", _m_Release); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "vertexs", _g_get_vertexs); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "uvs", _g_get_uvs); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "vertexs", _s_set_vertexs); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "uvs", _s_set_uvs); + + + 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.MeshInfo(); + 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.MeshInfo constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Reset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.MeshInfo gen_to_be_invoked = (BF.MeshInfo)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Reset( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Release(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.MeshInfo gen_to_be_invoked = (BF.MeshInfo)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Release( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_vertexs(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.MeshInfo gen_to_be_invoked = (BF.MeshInfo)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.vertexs); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_uvs(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.MeshInfo gen_to_be_invoked = (BF.MeshInfo)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.uvs); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_vertexs(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.MeshInfo gen_to_be_invoked = (BF.MeshInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.vertexs = (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; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_uvs(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.MeshInfo gen_to_be_invoked = (BF.MeshInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.uvs = (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/BF_MirrorWrap.cs b/Assets/XLua/Gen/BF_MirrorWrap.cs new file mode 100644 index 000000000..b0d53c7ec --- /dev/null +++ b/Assets/XLua/Gen/BF_MirrorWrap.cs @@ -0,0 +1,188 @@ +#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 BFMirrorWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.Mirror); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 2, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetNativeSize", _m_SetNativeSize); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ModifyMesh", _m_ModifyMesh); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mirrorType", _g_get_mirrorType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rectTransform", _g_get_rectTransform); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "mirrorType", _s_set_mirrorType); + + + 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.Mirror(); + 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.Mirror constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetNativeSize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.Mirror gen_to_be_invoked = (BF.Mirror)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetNativeSize( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ModifyMesh(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.Mirror gen_to_be_invoked = (BF.Mirror)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.UI.VertexHelper _vh = (UnityEngine.UI.VertexHelper)translator.GetObject(L, 2, typeof(UnityEngine.UI.VertexHelper)); + + gen_to_be_invoked.ModifyMesh( _vh ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mirrorType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.Mirror gen_to_be_invoked = (BF.Mirror)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.mirrorType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rectTransform(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.Mirror gen_to_be_invoked = (BF.Mirror)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.rectTransform); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_mirrorType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.Mirror gen_to_be_invoked = (BF.Mirror)translator.FastGetCSObj(L, 1); + BF.Mirror.MirrorType gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.mirrorType = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_MonoSingleton_1_AdManager_Wrap.cs b/Assets/XLua/Gen/BF_MonoSingleton_1_AdManager_Wrap.cs new file mode 100644 index 000000000..3c7ac7ec8 --- /dev/null +++ b/Assets/XLua/Gen/BF_MonoSingleton_1_AdManager_Wrap.cs @@ -0,0 +1,97 @@ +#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 BFMonoSingleton_1_AdManager_Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.MonoSingleton); + 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, 1, 0); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "Instance", _g_get_Instance); + + + + 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.MonoSingleton(); + 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.MonoSingleton constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Instance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, BF.MonoSingleton.Instance); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_MonoSingleton_1_BF_BFMain_Wrap.cs b/Assets/XLua/Gen/BF_MonoSingleton_1_BF_BFMain_Wrap.cs new file mode 100644 index 000000000..c177bb5b6 --- /dev/null +++ b/Assets/XLua/Gen/BF_MonoSingleton_1_BF_BFMain_Wrap.cs @@ -0,0 +1,97 @@ +#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 BFMonoSingleton_1_BFBFMain_Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.MonoSingleton); + 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, 1, 0); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "Instance", _g_get_Instance); + + + + 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.MonoSingleton(); + 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.MonoSingleton constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Instance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, BF.MonoSingleton.Instance); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_MultipleSpriteAnimationWrap.cs b/Assets/XLua/Gen/BF_MultipleSpriteAnimationWrap.cs new file mode 100644 index 000000000..195767ee3 --- /dev/null +++ b/Assets/XLua/Gen/BF_MultipleSpriteAnimationWrap.cs @@ -0,0 +1,211 @@ +#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 BFMultipleSpriteAnimationWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.MultipleSpriteAnimation); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSpriteList", _m_SetSpriteList); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PlayAnimation", _m_PlayAnimation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetOder", _m_SetOder); + + + + + + 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.MultipleSpriteAnimation(); + 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.MultipleSpriteAnimation constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSpriteList(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.MultipleSpriteAnimation gen_to_be_invoked = (BF.MultipleSpriteAnimation)translator.FastGetCSObj(L, 1); + + + + { + BF.SimpleAtlas _atlas = (BF.SimpleAtlas)translator.GetObject(L, 2, typeof(BF.SimpleAtlas)); + + gen_to_be_invoked.SetSpriteList( _atlas ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PlayAnimation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.MultipleSpriteAnimation gen_to_be_invoked = (BF.MultipleSpriteAnimation)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + bool _isLoop = LuaAPI.lua_toboolean(L, 2); + float _interval = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.PlayAnimation( _isLoop, _interval ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isLoop = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.PlayAnimation( _isLoop ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + int _endIndex = LuaAPI.xlua_tointeger(L, 3); + bool _isLoop = LuaAPI.lua_toboolean(L, 4); + float _interval = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.PlayAnimation( _startIndex, _endIndex, _isLoop, _interval ); + + + + return 0; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + int _endIndex = LuaAPI.xlua_tointeger(L, 3); + bool _isLoop = LuaAPI.lua_toboolean(L, 4); + + gen_to_be_invoked.PlayAnimation( _startIndex, _endIndex, _isLoop ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.MultipleSpriteAnimation.PlayAnimation!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetOder(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.MultipleSpriteAnimation gen_to_be_invoked = (BF.MultipleSpriteAnimation)translator.FastGetCSObj(L, 1); + + + + { + int _order = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetOder( _order ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_NativeCore_ThirdPlatform_AppsFlyerSdkWrap.cs b/Assets/XLua/Gen/BF_NativeCore_ThirdPlatform_AppsFlyerSdkWrap.cs new file mode 100644 index 000000000..7a98a45a3 --- /dev/null +++ b/Assets/XLua/Gen/BF_NativeCore_ThirdPlatform_AppsFlyerSdkWrap.cs @@ -0,0 +1,201 @@ +#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 BFNativeCoreThirdPlatformAppsFlyerSdkWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.NativeCore.ThirdPlatform.AppsFlyerSdk); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SendEvent", _m_SendEvent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LogAdRevenue", _m_LogAdRevenue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTaAccountId", _m_SetTaAccountId); + + + + + + 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.NativeCore.ThirdPlatform.AppsFlyerSdk(); + 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.NativeCore.ThirdPlatform.AppsFlyerSdk constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NativeCore.ThirdPlatform.AppsFlyerSdk gen_to_be_invoked = (BF.NativeCore.ThirdPlatform.AppsFlyerSdk)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SendEvent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NativeCore.ThirdPlatform.AppsFlyerSdk gen_to_be_invoked = (BF.NativeCore.ThirdPlatform.AppsFlyerSdk)translator.FastGetCSObj(L, 1); + + + + { + string _eventName = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 3, typeof(System.Collections.Generic.Dictionary)); + + gen_to_be_invoked.SendEvent( _eventName, _properties ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LogAdRevenue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NativeCore.ThirdPlatform.AppsFlyerSdk gen_to_be_invoked = (BF.NativeCore.ThirdPlatform.AppsFlyerSdk)translator.FastGetCSObj(L, 1); + + + + { + AppsFlyerSDK.AFAdRevenueData _adRevenueData = (AppsFlyerSDK.AFAdRevenueData)translator.GetObject(L, 2, typeof(AppsFlyerSDK.AFAdRevenueData)); + System.Collections.Generic.Dictionary _additionalParameters = (System.Collections.Generic.Dictionary)translator.GetObject(L, 3, typeof(System.Collections.Generic.Dictionary)); + + gen_to_be_invoked.LogAdRevenue( _adRevenueData, _additionalParameters ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTaAccountId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NativeCore.ThirdPlatform.AppsFlyerSdk gen_to_be_invoked = (BF.NativeCore.ThirdPlatform.AppsFlyerSdk)translator.FastGetCSObj(L, 1); + + + + { + string _accountId = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SetTaAccountId( _accountId ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_NativeCore_ThirdPlatform_FacebookSdkWrap.cs b/Assets/XLua/Gen/BF_NativeCore_ThirdPlatform_FacebookSdkWrap.cs new file mode 100644 index 000000000..c5648eae9 --- /dev/null +++ b/Assets/XLua/Gen/BF_NativeCore_ThirdPlatform_FacebookSdkWrap.cs @@ -0,0 +1,408 @@ +#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 BFNativeCoreThirdPlatformFacebookSdkWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.NativeCore.ThirdPlatform.FacebookSdk); + Utils.BeginObjectRegister(type, L, translator, 0, 9, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Login", _m_Login); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Logout", _m_Logout); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetULoginListener", _m_SetULoginListener); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LogAppEvent", _m_LogAppEvent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LogAppEventWithValue", _m_LogAppEventWithValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LogPurchase", _m_LogPurchase); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LogPurchaseDecimal", _m_LogPurchaseDecimal); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnApplicationPause", _m_OnApplicationPause); + + + + + + 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.NativeCore.ThirdPlatform.FacebookSdk(); + 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.NativeCore.ThirdPlatform.FacebookSdk constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NativeCore.ThirdPlatform.FacebookSdk gen_to_be_invoked = (BF.NativeCore.ThirdPlatform.FacebookSdk)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Login(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NativeCore.ThirdPlatform.FacebookSdk gen_to_be_invoked = (BF.NativeCore.ThirdPlatform.FacebookSdk)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Login( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Logout(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NativeCore.ThirdPlatform.FacebookSdk gen_to_be_invoked = (BF.NativeCore.ThirdPlatform.FacebookSdk)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Logout( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetULoginListener(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NativeCore.ThirdPlatform.FacebookSdk gen_to_be_invoked = (BF.NativeCore.ThirdPlatform.FacebookSdk)translator.FastGetCSObj(L, 1); + + + + { + BF.NativeCore.IULoginListener _listeners = (BF.NativeCore.IULoginListener)translator.GetObject(L, 2, typeof(BF.NativeCore.IULoginListener)); + + gen_to_be_invoked.SetULoginListener( _listeners ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LogAppEvent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NativeCore.ThirdPlatform.FacebookSdk gen_to_be_invoked = (BF.NativeCore.ThirdPlatform.FacebookSdk)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 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 _logEvent = LuaAPI.lua_tostring(L, 2); + string _data = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.LogAppEvent( _logEvent, _data ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _logEvent = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.LogAppEvent( _logEvent ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.NativeCore.ThirdPlatform.FacebookSdk.LogAppEvent!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LogAppEventWithValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NativeCore.ThirdPlatform.FacebookSdk gen_to_be_invoked = (BF.NativeCore.ThirdPlatform.FacebookSdk)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)) + { + string _logEvent = LuaAPI.lua_tostring(L, 2); + float _valueToSum = (float)LuaAPI.lua_tonumber(L, 3); + string _data = LuaAPI.lua_tostring(L, 4); + + gen_to_be_invoked.LogAppEventWithValue( _logEvent, _valueToSum, _data ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + string _logEvent = LuaAPI.lua_tostring(L, 2); + float _valueToSum = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.LogAppEventWithValue( _logEvent, _valueToSum ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.NativeCore.ThirdPlatform.FacebookSdk.LogAppEventWithValue!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LogPurchase(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NativeCore.ThirdPlatform.FacebookSdk gen_to_be_invoked = (BF.NativeCore.ThirdPlatform.FacebookSdk)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)) + { + float _logPurchase = (float)LuaAPI.lua_tonumber(L, 2); + string _currency = LuaAPI.lua_tostring(L, 3); + string _data = LuaAPI.lua_tostring(L, 4); + + gen_to_be_invoked.LogPurchase( _logPurchase, _currency, _data ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + float _logPurchase = (float)LuaAPI.lua_tonumber(L, 2); + string _currency = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.LogPurchase( _logPurchase, _currency ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.NativeCore.ThirdPlatform.FacebookSdk.LogPurchase!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LogPurchaseDecimal(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NativeCore.ThirdPlatform.FacebookSdk gen_to_be_invoked = (BF.NativeCore.ThirdPlatform.FacebookSdk)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) || translator.IsDecimal(L, 2))&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)) + { + decimal _logPurchase;translator.Get(L, 2, out _logPurchase); + string _currency = LuaAPI.lua_tostring(L, 3); + string _data = LuaAPI.lua_tostring(L, 4); + + gen_to_be_invoked.LogPurchaseDecimal( _logPurchase, _currency, _data ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) || translator.IsDecimal(L, 2))&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + decimal _logPurchase;translator.Get(L, 2, out _logPurchase); + string _currency = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.LogPurchaseDecimal( _logPurchase, _currency ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.NativeCore.ThirdPlatform.FacebookSdk.LogPurchaseDecimal!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnApplicationPause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NativeCore.ThirdPlatform.FacebookSdk gen_to_be_invoked = (BF.NativeCore.ThirdPlatform.FacebookSdk)translator.FastGetCSObj(L, 1); + + + + { + bool _pauseStatus = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.OnApplicationPause( _pauseStatus ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_NativeCore_ThirdPlatform_ThinkingAnalyticsSdkWrap.cs b/Assets/XLua/Gen/BF_NativeCore_ThirdPlatform_ThinkingAnalyticsSdkWrap.cs new file mode 100644 index 000000000..d5ae26ac7 --- /dev/null +++ b/Assets/XLua/Gen/BF_NativeCore_ThirdPlatform_ThinkingAnalyticsSdkWrap.cs @@ -0,0 +1,298 @@ +#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 BFNativeCoreThirdPlatformThinkingAnalyticsSdkWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.NativeCore.ThirdPlatform.ThinkingAnalyticsSdk); + Utils.BeginObjectRegister(type, L, translator, 0, 6, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAccountId", _m_SetAccountId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearAccountId", _m_ClearAccountId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Track", _m_Track); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetDistinctId", _m_GetDistinctId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CalibrateTime", _m_CalibrateTime); + + + + + + 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.NativeCore.ThirdPlatform.ThinkingAnalyticsSdk(); + 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.NativeCore.ThirdPlatform.ThinkingAnalyticsSdk constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NativeCore.ThirdPlatform.ThinkingAnalyticsSdk gen_to_be_invoked = (BF.NativeCore.ThirdPlatform.ThinkingAnalyticsSdk)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAccountId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NativeCore.ThirdPlatform.ThinkingAnalyticsSdk gen_to_be_invoked = (BF.NativeCore.ThirdPlatform.ThinkingAnalyticsSdk)translator.FastGetCSObj(L, 1); + + + + { + string _id = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SetAccountId( _id ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearAccountId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NativeCore.ThirdPlatform.ThinkingAnalyticsSdk gen_to_be_invoked = (BF.NativeCore.ThirdPlatform.ThinkingAnalyticsSdk)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearAccountId( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Track(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NativeCore.ThirdPlatform.ThinkingAnalyticsSdk gen_to_be_invoked = (BF.NativeCore.ThirdPlatform.ThinkingAnalyticsSdk)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 3)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)) + { + string _eventName = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 3, typeof(System.Collections.Generic.Dictionary)); + string _appId = LuaAPI.lua_tostring(L, 4); + + gen_to_be_invoked.Track( _eventName, _properties, _appId ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 3)) + { + string _eventName = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 3, typeof(System.Collections.Generic.Dictionary)); + + gen_to_be_invoked.Track( _eventName, _properties ); + + + + return 0; + } + if(gen_param_count == 5&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 3)&& translator.Assignable(L, 4)&& (LuaAPI.lua_isnil(L, 5) || LuaAPI.lua_type(L, 5) == LuaTypes.LUA_TSTRING)) + { + string _eventName = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 3, typeof(System.Collections.Generic.Dictionary)); + System.DateTime _date;translator.Get(L, 4, out _date); + string _appId = LuaAPI.lua_tostring(L, 5); + + gen_to_be_invoked.Track( _eventName, _properties, _date, _appId ); + + + + return 0; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 3)&& translator.Assignable(L, 4)) + { + string _eventName = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 3, typeof(System.Collections.Generic.Dictionary)); + System.DateTime _date;translator.Get(L, 4, out _date); + + gen_to_be_invoked.Track( _eventName, _properties, _date ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.NativeCore.ThirdPlatform.ThinkingAnalyticsSdk.Track!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetDistinctId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NativeCore.ThirdPlatform.ThinkingAnalyticsSdk gen_to_be_invoked = (BF.NativeCore.ThirdPlatform.ThinkingAnalyticsSdk)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetDistinctId( ); + 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 _m_CalibrateTime(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NativeCore.ThirdPlatform.ThinkingAnalyticsSdk gen_to_be_invoked = (BF.NativeCore.ThirdPlatform.ThinkingAnalyticsSdk)translator.FastGetCSObj(L, 1); + + + + { + long _timestamp = LuaAPI.lua_toint64(L, 2); + + gen_to_be_invoked.CalibrateTime( _timestamp ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_NativeUtilsWrap.cs b/Assets/XLua/Gen/BF_NativeUtilsWrap.cs new file mode 100644 index 000000000..a33441eda --- /dev/null +++ b/Assets/XLua/Gen/BF_NativeUtilsWrap.cs @@ -0,0 +1,208 @@ +#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 BFNativeUtilsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.NativeUtils); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 6, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetLanguageAndCountry", _m_GetLanguageAndCountry_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetTimeZone", _m_GetTimeZone_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "BindGetKeyChainUser", _m_BindGetKeyChainUser_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "BindSetKeyChainUser", _m_BindSetKeyChainUser_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "BindDeleteKeyChainUser", _m_BindDeleteKeyChainUser_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 BF.NativeUtils(); + 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.NativeUtils constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetLanguageAndCountry_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.NativeUtils.GetLanguageAndCountry( ); + 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 _m_GetTimeZone_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.NativeUtils.GetTimeZone( ); + 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 _m_BindGetKeyChainUser_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.NativeUtils.BindGetKeyChainUser( ); + 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 _m_BindSetKeyChainUser_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _uuid = LuaAPI.lua_tostring(L, 1); + + BF.NativeUtils.BindSetKeyChainUser( _uuid ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_BindDeleteKeyChainUser_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + BF.NativeUtils.BindDeleteKeyChainUser( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_NetAesEncryptWrap.cs b/Assets/XLua/Gen/BF_NetAesEncryptWrap.cs new file mode 100644 index 000000000..23e63878d --- /dev/null +++ b/Assets/XLua/Gen/BF_NetAesEncryptWrap.cs @@ -0,0 +1,300 @@ +#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 BFNetAesEncryptWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.NetAesEncrypt); + Utils.BeginObjectRegister(type, L, translator, 0, 6, 1, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CreateEncryptor", _m_CreateEncryptor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CreateDecryptor", _m_CreateDecryptor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GenerateKey", _m_GenerateKey); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GenerateIV", _m_GenerateIV); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Encrypt", _m_Encrypt); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Decrypt", _m_Decrypt); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "aesKey", _g_get_aesKey); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "aesKey", _s_set_aesKey); + + + 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) == 2 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + byte[] _counter = LuaAPI.lua_tobytes(L, 2); + + var gen_ret = new BF.NetAesEncrypt(_counter); + 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.NetAesEncrypt constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CreateEncryptor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetAesEncrypt gen_to_be_invoked = (BF.NetAesEncrypt)translator.FastGetCSObj(L, 1); + + + + { + byte[] _rgbKey = LuaAPI.lua_tobytes(L, 2); + byte[] _ignoredParameter = LuaAPI.lua_tobytes(L, 3); + + var gen_ret = gen_to_be_invoked.CreateEncryptor( _rgbKey, _ignoredParameter ); + 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_CreateDecryptor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetAesEncrypt gen_to_be_invoked = (BF.NetAesEncrypt)translator.FastGetCSObj(L, 1); + + + + { + byte[] _rgbKey = LuaAPI.lua_tobytes(L, 2); + byte[] _ignoredParameter = LuaAPI.lua_tobytes(L, 3); + + var gen_ret = gen_to_be_invoked.CreateDecryptor( _rgbKey, _ignoredParameter ); + 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_GenerateKey(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetAesEncrypt gen_to_be_invoked = (BF.NetAesEncrypt)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.GenerateKey( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GenerateIV(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetAesEncrypt gen_to_be_invoked = (BF.NetAesEncrypt)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.GenerateIV( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Encrypt(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetAesEncrypt gen_to_be_invoked = (BF.NetAesEncrypt)translator.FastGetCSObj(L, 1); + + + + { + byte[] _inputBuffer = LuaAPI.lua_tobytes(L, 2); + int _inputOffset = LuaAPI.xlua_tointeger(L, 3); + int _inputCount = LuaAPI.xlua_tointeger(L, 4); + byte[] _outputBuffer = LuaAPI.lua_tobytes(L, 5); + int _outputOffset = LuaAPI.xlua_tointeger(L, 6); + + gen_to_be_invoked.Encrypt( _inputBuffer, _inputOffset, _inputCount, _outputBuffer, _outputOffset ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Decrypt(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetAesEncrypt gen_to_be_invoked = (BF.NetAesEncrypt)translator.FastGetCSObj(L, 1); + + + + { + byte[] _inputBuffer = LuaAPI.lua_tobytes(L, 2); + int _inputOffset = LuaAPI.xlua_tointeger(L, 3); + int _inputCount = LuaAPI.xlua_tointeger(L, 4); + byte[] _outputBuffer = LuaAPI.lua_tobytes(L, 5); + int _outputOffset = LuaAPI.xlua_tointeger(L, 6); + + gen_to_be_invoked.Decrypt( _inputBuffer, _inputOffset, _inputCount, _outputBuffer, _outputOffset ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_aesKey(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetAesEncrypt gen_to_be_invoked = (BF.NetAesEncrypt)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.aesKey); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_aesKey(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetAesEncrypt gen_to_be_invoked = (BF.NetAesEncrypt)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.aesKey = LuaAPI.lua_tobytes(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_NetClientWrap.cs b/Assets/XLua/Gen/BF_NetClientWrap.cs new file mode 100644 index 000000000..c68fc3661 --- /dev/null +++ b/Assets/XLua/Gen/BF_NetClientWrap.cs @@ -0,0 +1,481 @@ +#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 BFNetClientWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.NetClient); + Utils.BeginObjectRegister(type, L, translator, 0, 13, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Start", _m_Start); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Shutdown", _m_Shutdown); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetupService", _m_SetupService); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Connect", _m_Connect); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Reconnect", _m_Reconnect); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Close", _m_Close); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Send", _m_Send); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ReadMessage", _m_ReadMessage); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RecycleMessage", _m_RecycleMessage); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetConnectStatus", _m_GetConnectStatus); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetConnectIP", _m_GetConnectIP); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetServerTimestamp", _m_GetServerTimestamp); + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 1, 0); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "Instance", _g_get_Instance); + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "BF.NetClient does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetClient gen_to_be_invoked = (BF.NetClient)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Start(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetClient gen_to_be_invoked = (BF.NetClient)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Start( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Shutdown(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetClient gen_to_be_invoked = (BF.NetClient)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Shutdown( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetupService(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetClient gen_to_be_invoked = (BF.NetClient)translator.FastGetCSObj(L, 1); + + + + { + BF.NetConfiguration _configuration = (BF.NetConfiguration)translator.GetObject(L, 2, typeof(BF.NetConfiguration)); + + gen_to_be_invoked.SetupService( _configuration ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Connect(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetClient gen_to_be_invoked = (BF.NetClient)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + BF.NetConnectConfiguration _configuration = (BF.NetConnectConfiguration)translator.GetObject(L, 2, typeof(BF.NetConnectConfiguration)); + string _domainName = LuaAPI.lua_tostring(L, 3); + int _port = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.Connect( _configuration, _domainName, _port ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + BF.NetConnectConfiguration _configuration = (BF.NetConnectConfiguration)translator.GetObject(L, 2, typeof(BF.NetConnectConfiguration)); + System.Net.IPAddress _ipAddress = (System.Net.IPAddress)translator.GetObject(L, 3, typeof(System.Net.IPAddress)); + int _port = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.Connect( _configuration, _ipAddress, _port ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.NetClient.Connect!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Reconnect(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetClient gen_to_be_invoked = (BF.NetClient)translator.FastGetCSObj(L, 1); + + + + { + string _uniqueIdentifier = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.Reconnect( _uniqueIdentifier ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Close(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetClient gen_to_be_invoked = (BF.NetClient)translator.FastGetCSObj(L, 1); + + + + { + string _uniqueIdentifier = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.Close( _uniqueIdentifier ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Send(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetClient gen_to_be_invoked = (BF.NetClient)translator.FastGetCSObj(L, 1); + + + + { + string _uniqueIdentifier = LuaAPI.lua_tostring(L, 2); + uint _group = LuaAPI.xlua_touint(L, 3); + byte _cmd = (byte)LuaAPI.xlua_tointeger(L, 4); + byte[] _data = LuaAPI.lua_tobytes(L, 5); + + var gen_ret = gen_to_be_invoked.Send( _uniqueIdentifier, _group, _cmd, _data ); + 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_ReadMessage(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetClient gen_to_be_invoked = (BF.NetClient)translator.FastGetCSObj(L, 1); + + + + { + string _uniqueIdentifier = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.ReadMessage( _uniqueIdentifier ); + 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_RecycleMessage(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetClient gen_to_be_invoked = (BF.NetClient)translator.FastGetCSObj(L, 1); + + + + { + string _uniqueIdentifier = LuaAPI.lua_tostring(L, 2); + BF.INetIncomingMessage _message = (BF.INetIncomingMessage)translator.GetObject(L, 3, typeof(BF.INetIncomingMessage)); + + gen_to_be_invoked.RecycleMessage( _uniqueIdentifier, _message ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetConnectStatus(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetClient gen_to_be_invoked = (BF.NetClient)translator.FastGetCSObj(L, 1); + + + + { + string _uniqueIdentifier = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetConnectStatus( _uniqueIdentifier ); + 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_GetConnectIP(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetClient gen_to_be_invoked = (BF.NetClient)translator.FastGetCSObj(L, 1); + + + + { + string _uniqueIdentifier = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetConnectIP( _uniqueIdentifier ); + 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 _m_GetServerTimestamp(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetClient gen_to_be_invoked = (BF.NetClient)translator.FastGetCSObj(L, 1); + + + + { + string _uniqueIdentifier = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetServerTimestamp( _uniqueIdentifier ); + LuaAPI.lua_pushint64(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_Instance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, BF.NetClient.Instance); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_NetConfigurationWrap.cs b/Assets/XLua/Gen/BF_NetConfigurationWrap.cs new file mode 100644 index 000000000..ad26df6ae --- /dev/null +++ b/Assets/XLua/Gen/BF_NetConfigurationWrap.cs @@ -0,0 +1,147 @@ +#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 BFNetConfigurationWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.NetConfiguration); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 2); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ServiceType", _g_get_ServiceType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ThreadName", _g_get_ThreadName); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ServiceType", _s_set_ServiceType); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ThreadName", _s_set_ThreadName); + + + 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.NetConfiguration(); + 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.NetConfiguration constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ServiceType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConfiguration gen_to_be_invoked = (BF.NetConfiguration)translator.FastGetCSObj(L, 1); + translator.PushBFNetServiceType(L, gen_to_be_invoked.ServiceType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ThreadName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConfiguration gen_to_be_invoked = (BF.NetConfiguration)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.ThreadName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_ServiceType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConfiguration gen_to_be_invoked = (BF.NetConfiguration)translator.FastGetCSObj(L, 1); + BF.NetServiceType gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.ServiceType = 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_ThreadName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConfiguration gen_to_be_invoked = (BF.NetConfiguration)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ThreadName = 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/BF_NetConnectConfigurationWrap.cs b/Assets/XLua/Gen/BF_NetConnectConfigurationWrap.cs new file mode 100644 index 000000000..21c0e1c50 --- /dev/null +++ b/Assets/XLua/Gen/BF_NetConnectConfigurationWrap.cs @@ -0,0 +1,638 @@ +#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 BFNetConnectConfigurationWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.NetConnectConfiguration); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 16, 14); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "EnableMessageType", _m_EnableMessageType); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DisableMessageType", _m_DisableMessageType); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsMessageTypeEnabled", _m_IsMessageTypeEnabled); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ServiceType", _g_get_ServiceType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "UniqueIdentifier", _g_get_UniqueIdentifier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "InitializeExchangeRc4Key", _g_get_InitializeExchangeRc4Key); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "SendBufferCapacity", _g_get_SendBufferCapacity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ReceiveBufferCapacity", _g_get_ReceiveBufferCapacity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "MessagePoolCapacity", _g_get_MessagePoolCapacity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AlreadySendMessageCacheCount", _g_get_AlreadySendMessageCacheCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "EnableSilenceReconnect", _g_get_EnableSilenceReconnect); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AutoReconnectCount", _g_get_AutoReconnectCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ReconnectTimeoutTime", _g_get_ReconnectTimeoutTime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ReconnectBaseInterval", _g_get_ReconnectBaseInterval); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "EnableHeartBeat", _g_get_EnableHeartBeat); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "HeartBeatInterval", _g_get_HeartBeatInterval); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "MaxHeartBeatMissCount", _g_get_MaxHeartBeatMissCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "EnableStatistics", _g_get_EnableStatistics); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ConnectTimeout", _g_get_ConnectTimeout); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "InitializeExchangeRc4Key", _s_set_InitializeExchangeRc4Key); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "SendBufferCapacity", _s_set_SendBufferCapacity); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ReceiveBufferCapacity", _s_set_ReceiveBufferCapacity); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "MessagePoolCapacity", _s_set_MessagePoolCapacity); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "AlreadySendMessageCacheCount", _s_set_AlreadySendMessageCacheCount); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "EnableSilenceReconnect", _s_set_EnableSilenceReconnect); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "AutoReconnectCount", _s_set_AutoReconnectCount); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ReconnectTimeoutTime", _s_set_ReconnectTimeoutTime); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ReconnectBaseInterval", _s_set_ReconnectBaseInterval); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "EnableHeartBeat", _s_set_EnableHeartBeat); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "HeartBeatInterval", _s_set_HeartBeatInterval); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "MaxHeartBeatMissCount", _s_set_MaxHeartBeatMissCount); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "EnableStatistics", _s_set_EnableStatistics); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ConnectTimeout", _s_set_ConnectTimeout); + + + 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 && translator.Assignable(L, 2) && (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + BF.NetServiceType _serviceType;translator.Get(L, 2, out _serviceType); + string _uniqueIdentifier = LuaAPI.lua_tostring(L, 3); + + var gen_ret = new BF.NetConnectConfiguration(_serviceType, _uniqueIdentifier); + 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.NetConnectConfiguration constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_EnableMessageType(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + + + + { + BF.NetIncomingMessageType _type;translator.Get(L, 2, out _type); + + gen_to_be_invoked.EnableMessageType( _type ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DisableMessageType(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + + + + { + BF.NetIncomingMessageType _type;translator.Get(L, 2, out _type); + + gen_to_be_invoked.DisableMessageType( _type ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsMessageTypeEnabled(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + + + + { + BF.NetIncomingMessageType _type;translator.Get(L, 2, out _type); + + var gen_ret = gen_to_be_invoked.IsMessageTypeEnabled( _type ); + 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 _g_get_ServiceType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + translator.PushBFNetServiceType(L, gen_to_be_invoked.ServiceType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UniqueIdentifier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.UniqueIdentifier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_InitializeExchangeRc4Key(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.InitializeExchangeRc4Key); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_SendBufferCapacity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.SendBufferCapacity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ReceiveBufferCapacity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.ReceiveBufferCapacity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_MessagePoolCapacity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.MessagePoolCapacity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AlreadySendMessageCacheCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.AlreadySendMessageCacheCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_EnableSilenceReconnect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.EnableSilenceReconnect); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AutoReconnectCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.AutoReconnectCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ReconnectTimeoutTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.ReconnectTimeoutTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ReconnectBaseInterval(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.ReconnectBaseInterval); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_EnableHeartBeat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.EnableHeartBeat); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_HeartBeatInterval(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.HeartBeatInterval); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_MaxHeartBeatMissCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.MaxHeartBeatMissCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_EnableStatistics(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.EnableStatistics); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ConnectTimeout(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.ConnectTimeout); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_InitializeExchangeRc4Key(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.InitializeExchangeRc4Key = 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_SendBufferCapacity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.SendBufferCapacity = 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_ReceiveBufferCapacity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ReceiveBufferCapacity = 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_MessagePoolCapacity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.MessagePoolCapacity = 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_AlreadySendMessageCacheCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.AlreadySendMessageCacheCount = 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_EnableSilenceReconnect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.EnableSilenceReconnect = 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_AutoReconnectCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.AutoReconnectCount = 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_ReconnectTimeoutTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ReconnectTimeoutTime = (float)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_ReconnectBaseInterval(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ReconnectBaseInterval = (float)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_EnableHeartBeat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.EnableHeartBeat = 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_HeartBeatInterval(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.HeartBeatInterval = (float)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_MaxHeartBeatMissCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.MaxHeartBeatMissCount = 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_EnableStatistics(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.EnableStatistics = 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_ConnectTimeout(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetConnectConfiguration gen_to_be_invoked = (BF.NetConnectConfiguration)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ConnectTimeout = (float)LuaAPI.lua_tonumber(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_NetErrorCodeWrap.cs b/Assets/XLua/Gen/BF_NetErrorCodeWrap.cs new file mode 100644 index 000000000..59c2513dc --- /dev/null +++ b/Assets/XLua/Gen/BF_NetErrorCodeWrap.cs @@ -0,0 +1,77 @@ +#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 BFNetErrorCodeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.NetErrorCode); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 11, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExceptionError", BF.NetErrorCode.ExceptionError); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ConnectFailed", BF.NetErrorCode.ConnectFailed); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReceiveBufferError", BF.NetErrorCode.ReceiveBufferError); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BeginSendError", BF.NetErrorCode.BeginSendError); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PeerDisconnect", BF.NetErrorCode.PeerDisconnect); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DataParseError", BF.NetErrorCode.DataParseError); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DNSParseDomainNameError", BF.NetErrorCode.DNSParseDomainNameError); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ServerRefuseReconnect", BF.NetErrorCode.ServerRefuseReconnect); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ServerKickNtfClient", BF.NetErrorCode.ServerKickNtfClient); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OtherDeviceLogin", BF.NetErrorCode.OtherDeviceLogin); + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "BF.NetErrorCode does not have a constructor!"); + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_NetExceptionWrap.cs b/Assets/XLua/Gen/BF_NetExceptionWrap.cs new file mode 100644 index 000000000..35f5401b7 --- /dev/null +++ b/Assets/XLua/Gen/BF_NetExceptionWrap.cs @@ -0,0 +1,143 @@ +#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 BFNetExceptionWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.NetException); + 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, "Assert", _m_Assert_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 BF.NetException(); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _message = LuaAPI.lua_tostring(L, 2); + + var gen_ret = new BF.NetException(_message); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 3 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING) && translator.Assignable(L, 3)) + { + string _message = LuaAPI.lua_tostring(L, 2); + System.Exception _inner = (System.Exception)translator.GetObject(L, 3, typeof(System.Exception)); + + var gen_ret = new BF.NetException(_message, _inner); + 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.NetException constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Assert_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)) + { + bool _isOk = LuaAPI.lua_toboolean(L, 1); + + BF.NetException.Assert( _isOk ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + bool _isOk = LuaAPI.lua_toboolean(L, 1); + string _message = LuaAPI.lua_tostring(L, 2); + + BF.NetException.Assert( _isOk, _message ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.NetException.Assert!"); + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_NetManagerWrap.cs b/Assets/XLua/Gen/BF_NetManagerWrap.cs new file mode 100644 index 000000000..38418fabc --- /dev/null +++ b/Assets/XLua/Gen/BF_NetManagerWrap.cs @@ -0,0 +1,1625 @@ +#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 BFNetManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.NetManager); + Utils.BeginObjectRegister(type, L, translator, 0, 42, 9, 9); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Update", _m_Update); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InitNetClientCount", _m_InitNetClientCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HandleDecodePbChange", _m_HandleDecodePbChange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetConnectIP", _m_GetConnectIP); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsConnected", _m_IsConnected); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsDisconnected", _m_IsDisconnected); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsAvailable", _m_IsAvailable); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsClosed", _m_IsClosed); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Reconnect", _m_Reconnect); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetServerTimestamp", _m_GetServerTimestamp); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ConnectWithDomainName", _m_ConnectWithDomainName); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ConnectWithConfiguration", _m_ConnectWithConfiguration); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Send", _m_Send); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Close", _m_Close); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAuthReqData", _m_GetAuthReqData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetChatAuthReqData", _m_GetChatAuthReqData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetLoginReqData", _m_GetLoginReqData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetDecodeStataus", _m_GetDecodeStataus); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetDecodeChatStataus", _m_GetDecodeChatStataus); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetDecodePbStr", _m_GetDecodePbStr); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetDecodeChatPbStr", _m_GetDecodeChatPbStr); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetDecodeGroup", _m_GetDecodeGroup); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetDecodeChatGroup", _m_GetDecodeChatGroup); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddLuaOnReceiveMessage", _m_AddLuaOnReceiveMessage); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveLuaOnReceiveMessage", _m_RemoveLuaOnReceiveMessage); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddLuaOnConnected", _m_AddLuaOnConnected); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveLuaOnConnected", _m_RemoveLuaOnConnected); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddLuaOnDisconnected", _m_AddLuaOnDisconnected); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveLuaOnDisconnected", _m_RemoveLuaOnDisconnected); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddLuaOnReconnectSuccess", _m_AddLuaOnReconnectSuccess); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveLuaOnReconnectSuccess", _m_RemoveLuaOnReconnectSuccess); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddLuaOnReconnect", _m_AddLuaOnReconnect); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveLuaOnReconnect", _m_RemoveLuaOnReconnect); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLuaAuthCallback", _m_SetLuaAuthCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLuaOnDecodePbCallback", _m_SetLuaOnDecodePbCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveLuaOnDecodePbCallback", _m_RemoveLuaOnDecodePbCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddLuaOnError", _m_AddLuaOnError); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveLuaOnError", _m_RemoveLuaOnError); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveAllLuaCallback", _m_RemoveAllLuaCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Destroy", _m_Destroy); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "luaAuthCallback", _e_luaAuthCallback); + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "loginReqData", _g_get_loginReqData); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "authReqData", _g_get_authReqData); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ChatAuthReqData", _g_get_ChatAuthReqData); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "decodePbStr", _g_get_decodePbStr); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "decodeChatPbStr", _g_get_decodeChatPbStr); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rspGroup", _g_get_rspGroup); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rspChatGroup", _g_get_rspChatGroup); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "decodeFinish", _g_get_decodeFinish); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "decodeChatFinish", _g_get_decodeChatFinish); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "loginReqData", _s_set_loginReqData); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "authReqData", _s_set_authReqData); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ChatAuthReqData", _s_set_ChatAuthReqData); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "decodePbStr", _s_set_decodePbStr); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "decodeChatPbStr", _s_set_decodeChatPbStr); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "rspGroup", _s_set_rspGroup); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "rspChatGroup", _s_set_rspChatGroup); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "decodeFinish", _s_set_decodeFinish); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "decodeChatFinish", _s_set_decodeChatFinish); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 6, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Create", _m_Create_xlua_st_); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MAIN_SOCKET_NAME", BF.NetManager.MAIN_SOCKET_NAME); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CHAT_SOCKET_NAME", BF.NetManager.CHAT_SOCKET_NAME); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MAIN_SOCKET_NAME_INT", BF.NetManager.MAIN_SOCKET_NAME_INT); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CHAT_SOCKET_NAME_INT", BF.NetManager.CHAT_SOCKET_NAME_INT); + + + + + 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.NetManager(); + 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.NetManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Create_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = BF.NetManager.Create( ); + 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_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Update(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Update( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_InitNetClientCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + int _count = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.InitNetClientCount( _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HandleDecodePbChange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + int _clientId = LuaAPI.xlua_tointeger(L, 2); + uint _group = LuaAPI.xlua_touint(L, 3); + uint _seq = LuaAPI.xlua_touint(L, 4); + byte[] _data = LuaAPI.lua_tobytes(L, 5); + + gen_to_be_invoked.HandleDecodePbChange( _clientId, _group, _seq, _data ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetConnectIP(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + int _clientId = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetConnectIP( _clientId ); + 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 _m_IsConnected(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + int _clientId = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.IsConnected( _clientId ); + 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_IsDisconnected(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + int _clientId = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.IsDisconnected( _clientId ); + 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_IsAvailable(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + int _clientId = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.IsAvailable( _clientId ); + 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_IsClosed(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + int _clientId = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.IsClosed( _clientId ); + 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_Reconnect(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + int _clientId = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.Reconnect( _clientId ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetServerTimestamp(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + int _clientId = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetServerTimestamp( _clientId ); + LuaAPI.lua_pushint64(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_ConnectWithDomainName(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + int _clientId = LuaAPI.xlua_tointeger(L, 2); + string _clientName = LuaAPI.lua_tostring(L, 3); + string _domainName = LuaAPI.lua_tostring(L, 4); + int _port = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.ConnectWithDomainName( _clientId, _clientName, _domainName, _port ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ConnectWithConfiguration(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + int _clientId = LuaAPI.xlua_tointeger(L, 2); + BF.NetConnectConfiguration _configuration = (BF.NetConnectConfiguration)translator.GetObject(L, 3, typeof(BF.NetConnectConfiguration)); + string _domainName = LuaAPI.lua_tostring(L, 4); + int _port = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.ConnectWithConfiguration( _clientId, _configuration, _domainName, _port ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Send(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + int _clientId = LuaAPI.xlua_tointeger(L, 2); + uint _group = LuaAPI.xlua_touint(L, 3); + byte _cmd = (byte)LuaAPI.xlua_tointeger(L, 4); + byte[] _data = LuaAPI.lua_tobytes(L, 5); + + gen_to_be_invoked.Send( _clientId, _group, _cmd, _data ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Close(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + int _clientId = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.Close( _clientId ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetAuthReqData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetAuthReqData( ); + 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 _m_GetChatAuthReqData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetChatAuthReqData( ); + 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 _m_GetLoginReqData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetLoginReqData( ); + 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 _m_GetDecodeStataus(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetDecodeStataus( ); + 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_GetDecodeChatStataus(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetDecodeChatStataus( ); + 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_GetDecodePbStr(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetDecodePbStr( ); + 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 _m_GetDecodeChatPbStr(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetDecodeChatPbStr( ); + 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 _m_GetDecodeGroup(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetDecodeGroup( ); + LuaAPI.xlua_pushuint(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_GetDecodeChatGroup(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetDecodeChatGroup( ); + LuaAPI.xlua_pushuint(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_AddLuaOnReceiveMessage(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _luaFunc = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.AddLuaOnReceiveMessage( _luaFunc ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveLuaOnReceiveMessage(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RemoveLuaOnReceiveMessage( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddLuaOnConnected(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _luaFunc = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.AddLuaOnConnected( _luaFunc ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveLuaOnConnected(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RemoveLuaOnConnected( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddLuaOnDisconnected(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _luaFunc = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.AddLuaOnDisconnected( _luaFunc ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveLuaOnDisconnected(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RemoveLuaOnDisconnected( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddLuaOnReconnectSuccess(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _luaFunc = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.AddLuaOnReconnectSuccess( _luaFunc ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveLuaOnReconnectSuccess(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RemoveLuaOnReconnectSuccess( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddLuaOnReconnect(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _luaFunc = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.AddLuaOnReconnect( _luaFunc ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveLuaOnReconnect(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RemoveLuaOnReconnect( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLuaAuthCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetLuaAuthCallback( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLuaOnDecodePbCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _luaFunc = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.SetLuaOnDecodePbCallback( _luaFunc ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveLuaOnDecodePbCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RemoveLuaOnDecodePbCallback( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddLuaOnError(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _luaFunc = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.AddLuaOnError( _luaFunc ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveLuaOnError(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RemoveLuaOnError( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveAllLuaCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RemoveAllLuaCallback( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Destroy(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Destroy( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_loginReqData(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.loginReqData); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_authReqData(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.authReqData); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ChatAuthReqData(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.ChatAuthReqData); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_decodePbStr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.decodePbStr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_decodeChatPbStr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.decodeChatPbStr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rspGroup(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushuint(L, gen_to_be_invoked.rspGroup); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rspChatGroup(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushuint(L, gen_to_be_invoked.rspChatGroup); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_decodeFinish(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.decodeFinish); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_decodeChatFinish(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.decodeChatFinish); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_loginReqData(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.loginReqData = LuaAPI.lua_tobytes(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_authReqData(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.authReqData = LuaAPI.lua_tobytes(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_ChatAuthReqData(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ChatAuthReqData = LuaAPI.lua_tobytes(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_decodePbStr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.decodePbStr = 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_decodeChatPbStr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.decodeChatPbStr = 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_rspGroup(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.rspGroup = LuaAPI.xlua_touint(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_rspChatGroup(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.rspChatGroup = LuaAPI.xlua_touint(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_decodeFinish(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.decodeFinish = 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_decodeChatFinish(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.decodeChatFinish = 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 _e_luaAuthCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + BF.NetManager gen_to_be_invoked = (BF.NetManager)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.luaAuthCallback += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.luaAuthCallback -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to BF.NetManager.luaAuthCallback!"); + return 0; + } + + + + } +} diff --git a/Assets/XLua/Gen/BF_NetMd5EncryptWrap.cs b/Assets/XLua/Gen/BF_NetMd5EncryptWrap.cs new file mode 100644 index 000000000..e6ef1c277 --- /dev/null +++ b/Assets/XLua/Gen/BF_NetMd5EncryptWrap.cs @@ -0,0 +1,137 @@ +#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 BFNetMd5EncryptWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.NetMd5Encrypt); + 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, "Encrypt", _m_Encrypt_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "VerifyMd5Hash", _m_VerifyMd5Hash_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 BF.NetMd5Encrypt(); + 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.NetMd5Encrypt constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Encrypt_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _value = LuaAPI.lua_tostring(L, 1); + + var gen_ret = BF.NetMd5Encrypt.Encrypt( _value ); + 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 _m_VerifyMd5Hash_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _input = LuaAPI.lua_tostring(L, 1); + string _hash = LuaAPI.lua_tostring(L, 2); + + var gen_ret = BF.NetMd5Encrypt.VerifyMd5Hash( _input, _hash ); + LuaAPI.lua_pushboolean(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_NodeHelperWrap.cs b/Assets/XLua/Gen/BF_NodeHelperWrap.cs new file mode 100644 index 000000000..9d124e73b --- /dev/null +++ b/Assets/XLua/Gen/BF_NodeHelperWrap.cs @@ -0,0 +1,645 @@ +#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 BFNodeHelperWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.NodeHelper); + Utils.BeginObjectRegister(type, L, translator, 0, 16, 4, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetGameObjectByName", _m_GetGameObjectByName); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetListCount", _m_GetListCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashNameByIndex", _m_GetHashNameByIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetObjectTypeByIndex", _m_GetObjectTypeByIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetGameObjectByIndex", _m_GetGameObjectByIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLocalPosition", _m_SetLocalPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CachePosition", _m_CachePosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPosition", _m_SetPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPositionX", _m_SetPositionX); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPositionY", _m_SetPositionY); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPositionZ", _m_SetPositionZ); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CacheLocalEulerAngles", _m_CacheLocalEulerAngles); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLocalEulerAngles", _m_SetLocalEulerAngles); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetLocalEulerAnglesZ", _m_GetLocalEulerAnglesZ); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLocalEulerAnglesZ", _m_SetLocalEulerAnglesZ); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLocalScale", _m_SetLocalScale); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PositionX", _g_get_PositionX); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PositionY", _g_get_PositionY); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PositionZ", _g_get_PositionZ); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "prefabList", _g_get_prefabList); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "prefabList", _s_set_prefabList); + + + 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.NodeHelper(); + 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.NodeHelper constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetGameObjectByName(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NodeHelper gen_to_be_invoked = (BF.NodeHelper)translator.FastGetCSObj(L, 1); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetGameObjectByName( _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_GetListCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NodeHelper gen_to_be_invoked = (BF.NodeHelper)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetListCount( ); + 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_GetHashNameByIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NodeHelper gen_to_be_invoked = (BF.NodeHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetHashNameByIndex( _index ); + LuaAPI.xlua_pushuint(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_GetObjectTypeByIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NodeHelper gen_to_be_invoked = (BF.NodeHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetObjectTypeByIndex( _index ); + 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_GetGameObjectByIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NodeHelper gen_to_be_invoked = (BF.NodeHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetGameObjectByIndex( _index ); + 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_SetLocalPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NodeHelper gen_to_be_invoked = (BF.NodeHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + float _z = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.SetLocalPosition( _index, _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CachePosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NodeHelper gen_to_be_invoked = (BF.NodeHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.CachePosition( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NodeHelper gen_to_be_invoked = (BF.NodeHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + float _z = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.SetPosition( _index, _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetPositionX(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NodeHelper gen_to_be_invoked = (BF.NodeHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetPositionX( _index, _x ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetPositionY(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NodeHelper gen_to_be_invoked = (BF.NodeHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetPositionY( _index, _y ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetPositionZ(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NodeHelper gen_to_be_invoked = (BF.NodeHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _z = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetPositionZ( _index, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CacheLocalEulerAngles(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NodeHelper gen_to_be_invoked = (BF.NodeHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.CacheLocalEulerAngles( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLocalEulerAngles(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NodeHelper gen_to_be_invoked = (BF.NodeHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + float _z = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.SetLocalEulerAngles( _index, _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetLocalEulerAnglesZ(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NodeHelper gen_to_be_invoked = (BF.NodeHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetLocalEulerAnglesZ( _index ); + LuaAPI.lua_pushnumber(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_SetLocalEulerAnglesZ(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NodeHelper gen_to_be_invoked = (BF.NodeHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _z = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetLocalEulerAnglesZ( _index, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLocalScale(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NodeHelper gen_to_be_invoked = (BF.NodeHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + float _z = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.SetLocalScale( _index, _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PositionX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NodeHelper gen_to_be_invoked = (BF.NodeHelper)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.PositionX); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PositionY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NodeHelper gen_to_be_invoked = (BF.NodeHelper)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.PositionY); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PositionZ(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NodeHelper gen_to_be_invoked = (BF.NodeHelper)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.PositionZ); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_prefabList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NodeHelper gen_to_be_invoked = (BF.NodeHelper)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.prefabList); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_prefabList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NodeHelper gen_to_be_invoked = (BF.NodeHelper)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.prefabList = (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/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_NotchScreenNodeWrap.cs b/Assets/XLua/Gen/BF_NotchScreenNodeWrap.cs new file mode 100644 index 000000000..1348d1842 --- /dev/null +++ b/Assets/XLua/Gen/BF_NotchScreenNodeWrap.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 BFNotchScreenNodeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.NotchScreenNode); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 2); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "gameObject", _g_get_gameObject); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "adjustHeight", _g_get_adjustHeight); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "gameObject", _s_set_gameObject); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "adjustHeight", _s_set_adjustHeight); + + + 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) + { + translator.Push(L, default(BF.NotchScreenNode)); + 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.NotchScreenNode constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_gameObject(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NotchScreenNode gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.gameObject); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_adjustHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NotchScreenNode gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.adjustHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_gameObject(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NotchScreenNode gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.gameObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_adjustHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NotchScreenNode gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.adjustHeight = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_NotificationInfoWrap.cs b/Assets/XLua/Gen/BF_NotificationInfoWrap.cs new file mode 100644 index 000000000..2afd78650 --- /dev/null +++ b/Assets/XLua/Gen/BF_NotificationInfoWrap.cs @@ -0,0 +1,301 @@ +#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 BFNotificationInfoWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.NotificationInfo); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 7, 7); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "title", _g_get_title); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "text", _g_get_text); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "day", _g_get_day); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "hour", _g_get_hour); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "minute", _g_get_minute); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "second", _g_get_second); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "repeat", _g_get_repeat); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "title", _s_set_title); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "text", _s_set_text); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "day", _s_set_day); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "hour", _s_set_hour); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "minute", _s_set_minute); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "second", _s_set_second); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "repeat", _s_set_repeat); + + + 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.NotificationInfo(); + 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.NotificationInfo constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_title(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NotificationInfo gen_to_be_invoked = (BF.NotificationInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.title); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_text(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NotificationInfo gen_to_be_invoked = (BF.NotificationInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.text); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_day(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NotificationInfo gen_to_be_invoked = (BF.NotificationInfo)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.day); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_hour(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NotificationInfo gen_to_be_invoked = (BF.NotificationInfo)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.hour); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_minute(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NotificationInfo gen_to_be_invoked = (BF.NotificationInfo)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.minute); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_second(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NotificationInfo gen_to_be_invoked = (BF.NotificationInfo)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.second); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_repeat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NotificationInfo gen_to_be_invoked = (BF.NotificationInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.repeat); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_title(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NotificationInfo gen_to_be_invoked = (BF.NotificationInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.title = 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_text(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NotificationInfo gen_to_be_invoked = (BF.NotificationInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.text = 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_day(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NotificationInfo gen_to_be_invoked = (BF.NotificationInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.day = 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_hour(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NotificationInfo gen_to_be_invoked = (BF.NotificationInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.hour = 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_minute(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NotificationInfo gen_to_be_invoked = (BF.NotificationInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.minute = 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_second(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NotificationInfo gen_to_be_invoked = (BF.NotificationInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.second = 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_repeat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.NotificationInfo gen_to_be_invoked = (BF.NotificationInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.repeat = LuaAPI.lua_toboolean(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_NotificationSDKManagerWrap.cs b/Assets/XLua/Gen/BF_NotificationSDKManagerWrap.cs new file mode 100644 index 000000000..3f0635015 --- /dev/null +++ b/Assets/XLua/Gen/BF_NotificationSDKManagerWrap.cs @@ -0,0 +1,264 @@ +#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 BFNotificationSDKManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.NotificationSDKManager); + Utils.BeginObjectRegister(type, L, translator, 0, 6, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InitPuchContent", _m_InitPuchContent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetNotificationChannel", _m_ResetNotificationChannel); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RegisterAndSendNotification", _m_RegisterAndSendNotification); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNotificationTime", _m_GetNotificationTime); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetIsOpenAppFromNotification", _m_GetIsOpenAppFromNotification); + + + + + + 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.NotificationSDKManager(); + 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.NotificationSDKManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NotificationSDKManager gen_to_be_invoked = (BF.NotificationSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_InitPuchContent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NotificationSDKManager gen_to_be_invoked = (BF.NotificationSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _title = LuaAPI.lua_tostring(L, 2); + string _content = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.InitPuchContent( _title, _content ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetNotificationChannel(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NotificationSDKManager gen_to_be_invoked = (BF.NotificationSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ResetNotificationChannel( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RegisterAndSendNotification(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NotificationSDKManager gen_to_be_invoked = (BF.NotificationSDKManager)translator.FastGetCSObj(L, 1); + + + + { + string _title = LuaAPI.lua_tostring(L, 2); + string _text = LuaAPI.lua_tostring(L, 3); + int _day = LuaAPI.xlua_tointeger(L, 4); + int _hour = LuaAPI.xlua_tointeger(L, 5); + int _minute = LuaAPI.xlua_tointeger(L, 6); + int _second = LuaAPI.xlua_tointeger(L, 7); + bool _repeat = LuaAPI.lua_toboolean(L, 8); + + gen_to_be_invoked.RegisterAndSendNotification( _title, _text, _day, _hour, _minute, _second, _repeat ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetNotificationTime(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NotificationSDKManager gen_to_be_invoked = (BF.NotificationSDKManager)translator.FastGetCSObj(L, 1); + + + + { + BF.NotificationInfo _notificationInfo = (BF.NotificationInfo)translator.GetObject(L, 2, typeof(BF.NotificationInfo)); + + var gen_ret = gen_to_be_invoked.GetNotificationTime( _notificationInfo ); + 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_GetIsOpenAppFromNotification(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.NotificationSDKManager gen_to_be_invoked = (BF.NotificationSDKManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetIsOpenAppFromNotification( ); + LuaAPI.lua_pushboolean(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_OnGetVersionProcessorWrap.cs b/Assets/XLua/Gen/BF_OnGetVersionProcessorWrap.cs new file mode 100644 index 000000000..a003e2199 --- /dev/null +++ b/Assets/XLua/Gen/BF_OnGetVersionProcessorWrap.cs @@ -0,0 +1,114 @@ +#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 BFOnGetVersionProcessorWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.OnGetVersionProcessor); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Process", _m_Process); + + + + + + 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) == 2 && translator.Assignable(L, 2)) + { + BF.GameLaunchProcessorBase _nextProcessor = (BF.GameLaunchProcessorBase)translator.GetObject(L, 2, typeof(BF.GameLaunchProcessorBase)); + + var gen_ret = new BF.OnGetVersionProcessor(_nextProcessor); + 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.OnGetVersionProcessor constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Process(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.OnGetVersionProcessor gen_to_be_invoked = (BF.OnGetVersionProcessor)translator.FastGetCSObj(L, 1); + + + + { + BF.LaunchRequester _lr = (BF.LaunchRequester)translator.GetObject(L, 2, typeof(BF.LaunchRequester)); + + gen_to_be_invoked.Process( _lr ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_OneShotManagerWrap.cs b/Assets/XLua/Gen/BF_OneShotManagerWrap.cs new file mode 100644 index 000000000..32557df09 --- /dev/null +++ b/Assets/XLua/Gen/BF_OneShotManagerWrap.cs @@ -0,0 +1,207 @@ +#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 BFOneShotManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.OneShotManager); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 0, 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, "Update", _m_Update); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddOneShot", _m_AddOneShot); + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Create", _m_Create_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "BF.OneShotManager does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Create_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = BF.OneShotManager.Create( ); + 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_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.OneShotManager gen_to_be_invoked = (BF.OneShotManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Destroy(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.OneShotManager gen_to_be_invoked = (BF.OneShotManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Destroy( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Update(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.OneShotManager gen_to_be_invoked = (BF.OneShotManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Update( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddOneShot(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.OneShotManager gen_to_be_invoked = (BF.OneShotManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _oneShot = translator.GetDelegate(L, 2); + + gen_to_be_invoked.AddOneShot( _oneShot ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_OutlineWrap.cs b/Assets/XLua/Gen/BF_OutlineWrap.cs new file mode 100644 index 000000000..eded1e891 --- /dev/null +++ b/Assets/XLua/Gen/BF_OutlineWrap.cs @@ -0,0 +1,179 @@ +#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 BFOutlineWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.Outline); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 3, 3); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "OutlineMode", _g_get_OutlineMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "OutlineColor", _g_get_OutlineColor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "OutlineWidth", _g_get_OutlineWidth); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "OutlineMode", _s_set_OutlineMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "OutlineColor", _s_set_OutlineColor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "OutlineWidth", _s_set_OutlineWidth); + + + 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.Outline(); + 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.Outline constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_OutlineMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.Outline gen_to_be_invoked = (BF.Outline)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.OutlineMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_OutlineColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.Outline gen_to_be_invoked = (BF.Outline)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineColor(L, gen_to_be_invoked.OutlineColor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_OutlineWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.Outline gen_to_be_invoked = (BF.Outline)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.OutlineWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_OutlineMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.Outline gen_to_be_invoked = (BF.Outline)translator.FastGetCSObj(L, 1); + BF.Outline.Mode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.OutlineMode = 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_OutlineColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.Outline gen_to_be_invoked = (BF.Outline)translator.FastGetCSObj(L, 1); + UnityEngine.Color gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.OutlineColor = 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_OutlineWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.Outline gen_to_be_invoked = (BF.Outline)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.OutlineWidth = (float)LuaAPI.lua_tonumber(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_PoolManagerWrap.cs b/Assets/XLua/Gen/BF_PoolManagerWrap.cs new file mode 100644 index 000000000..c9808b77b --- /dev/null +++ b/Assets/XLua/Gen/BF_PoolManagerWrap.cs @@ -0,0 +1,165 @@ +#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 BFPoolManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.PoolManager); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 1, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Destroy", _m_Destroy); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "GameObjPool", _g_get_GameObjPool); + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Create", _m_Create_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "BF.PoolManager does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Create_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = BF.PoolManager.Create( ); + 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_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PoolManager gen_to_be_invoked = (BF.PoolManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Destroy(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PoolManager gen_to_be_invoked = (BF.PoolManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Destroy( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_GameObjPool(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.PoolManager gen_to_be_invoked = (BF.PoolManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.GameObjPool); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_PostEffectBehaviourWrap.cs b/Assets/XLua/Gen/BF_PostEffectBehaviourWrap.cs new file mode 100644 index 000000000..8bfc09ec2 --- /dev/null +++ b/Assets/XLua/Gen/BF_PostEffectBehaviourWrap.cs @@ -0,0 +1,288 @@ +#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 BFPostEffectBehaviourWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.PostEffectBehaviour); + Utils.BeginObjectRegister(type, L, translator, 0, 5, 4, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CheckSupport", _m_CheckSupport); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPostEffectType", _m_SetPostEffectType); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OpenPostEffect", _m_OpenPostEffect); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClosePostEffect", _m_ClosePostEffect); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "EffectType", _g_get_EffectType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "VividBloomEffect", _g_get_VividBloomEffect); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "FxaaEffect", _g_get_FxaaEffect); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "RadialBlurEffetc", _g_get_RadialBlurEffetc); + + + + 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.PostEffectBehaviour(); + 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.PostEffectBehaviour constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CheckSupport(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PostEffectBehaviour gen_to_be_invoked = (BF.PostEffectBehaviour)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.CheckSupport( ); + 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_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PostEffectBehaviour gen_to_be_invoked = (BF.PostEffectBehaviour)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetPostEffectType(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PostEffectBehaviour gen_to_be_invoked = (BF.PostEffectBehaviour)translator.FastGetCSObj(L, 1); + + + + { + BF.PostEffectType _type;translator.Get(L, 2, out _type); + + gen_to_be_invoked.SetPostEffectType( _type ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OpenPostEffect(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PostEffectBehaviour gen_to_be_invoked = (BF.PostEffectBehaviour)translator.FastGetCSObj(L, 1); + + + + { + BF.PostEffectType _effectType;translator.Get(L, 2, out _effectType); + + gen_to_be_invoked.OpenPostEffect( _effectType ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClosePostEffect(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PostEffectBehaviour gen_to_be_invoked = (BF.PostEffectBehaviour)translator.FastGetCSObj(L, 1); + + + + { + BF.PostEffectType _effectType;translator.Get(L, 2, out _effectType); + + gen_to_be_invoked.ClosePostEffect( _effectType ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_EffectType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.PostEffectBehaviour gen_to_be_invoked = (BF.PostEffectBehaviour)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.EffectType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_VividBloomEffect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.PostEffectBehaviour gen_to_be_invoked = (BF.PostEffectBehaviour)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.VividBloomEffect); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_FxaaEffect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.PostEffectBehaviour gen_to_be_invoked = (BF.PostEffectBehaviour)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.FxaaEffect); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_RadialBlurEffetc(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.PostEffectBehaviour gen_to_be_invoked = (BF.PostEffectBehaviour)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.RadialBlurEffetc); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_PostEffectBloomWrap.cs b/Assets/XLua/Gen/BF_PostEffectBloomWrap.cs new file mode 100644 index 000000000..d7376330b --- /dev/null +++ b/Assets/XLua/Gen/BF_PostEffectBloomWrap.cs @@ -0,0 +1,300 @@ +#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 BFPostEffectBloomWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.PostEffectBloom); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 3, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetIteration", _m_SetIteration); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetDownSample", _m_SetDownSample); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLuminance", _m_SetLuminance); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRenderImage", _m_OnRenderImage); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Iterations", _g_get_Iterations); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "DownSample", _g_get_DownSample); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "LuminanceThreshold", _g_get_LuminanceThreshold); + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 2, 2); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "BlurSizeID", _g_get_BlurSizeID); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "BloomID", _g_get_BloomID); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "BlurSizeID", _s_set_BlurSizeID); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "BloomID", _s_set_BloomID); + + + 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.PostEffectBloom(); + 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.PostEffectBloom constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetIteration(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PostEffectBloom gen_to_be_invoked = (BF.PostEffectBloom)translator.FastGetCSObj(L, 1); + + + + { + int _iterations = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetIteration( _iterations ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetDownSample(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PostEffectBloom gen_to_be_invoked = (BF.PostEffectBloom)translator.FastGetCSObj(L, 1); + + + + { + int _downSample = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetDownSample( _downSample ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLuminance(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PostEffectBloom gen_to_be_invoked = (BF.PostEffectBloom)translator.FastGetCSObj(L, 1); + + + + { + float _luminanceThreshold = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.SetLuminance( _luminanceThreshold ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnRenderImage(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PostEffectBloom gen_to_be_invoked = (BF.PostEffectBloom)translator.FastGetCSObj(L, 1); + + + + { + BF.PostEffectContext _context = (BF.PostEffectContext)translator.GetObject(L, 2, typeof(BF.PostEffectContext)); + + var gen_ret = gen_to_be_invoked.OnRenderImage( _context ); + 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_Iterations(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.PostEffectBloom gen_to_be_invoked = (BF.PostEffectBloom)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Iterations); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DownSample(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.PostEffectBloom gen_to_be_invoked = (BF.PostEffectBloom)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.DownSample); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_LuminanceThreshold(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.PostEffectBloom gen_to_be_invoked = (BF.PostEffectBloom)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.LuminanceThreshold); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_BlurSizeID(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, BF.PostEffectBloom.BlurSizeID); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_BloomID(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, BF.PostEffectBloom.BloomID); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_BlurSizeID(RealStatePtr L) + { + try { + + BF.PostEffectBloom.BlurSizeID = LuaAPI.xlua_tointeger(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_BloomID(RealStatePtr L) + { + try { + + BF.PostEffectBloom.BloomID = LuaAPI.xlua_tointeger(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_PostEffectContextWrap.cs b/Assets/XLua/Gen/BF_PostEffectContextWrap.cs new file mode 100644 index 000000000..1c70e6a99 --- /dev/null +++ b/Assets/XLua/Gen/BF_PostEffectContextWrap.cs @@ -0,0 +1,156 @@ +#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 BFPostEffectContextWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.PostEffectContext); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 2); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "src", _g_get_src); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "dest", _g_get_dest); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "src", _s_set_src); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "dest", _s_set_dest); + + + 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.PostEffectContext(); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 3 && translator.Assignable(L, 2) && translator.Assignable(L, 3)) + { + UnityEngine.RenderTexture _src = (UnityEngine.RenderTexture)translator.GetObject(L, 2, typeof(UnityEngine.RenderTexture)); + UnityEngine.RenderTexture _dest = (UnityEngine.RenderTexture)translator.GetObject(L, 3, typeof(UnityEngine.RenderTexture)); + + var gen_ret = new BF.PostEffectContext(_src, _dest); + 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.PostEffectContext constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_src(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.PostEffectContext gen_to_be_invoked = (BF.PostEffectContext)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.src); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_dest(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.PostEffectContext gen_to_be_invoked = (BF.PostEffectContext)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.dest); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_src(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.PostEffectContext gen_to_be_invoked = (BF.PostEffectContext)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.src = (UnityEngine.RenderTexture)translator.GetObject(L, 2, typeof(UnityEngine.RenderTexture)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_dest(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.PostEffectContext gen_to_be_invoked = (BF.PostEffectContext)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.dest = (UnityEngine.RenderTexture)translator.GetObject(L, 2, typeof(UnityEngine.RenderTexture)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_PostEffectFxaaWrap.cs b/Assets/XLua/Gen/BF_PostEffectFxaaWrap.cs new file mode 100644 index 000000000..2fd0c7ba7 --- /dev/null +++ b/Assets/XLua/Gen/BF_PostEffectFxaaWrap.cs @@ -0,0 +1,129 @@ +#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 BFPostEffectFxaaWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.PostEffectFxaa); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 1, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRenderImage", _m_OnRenderImage); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "FxaaMaterial", _g_get_FxaaMaterial); + + + + 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.PostEffectFxaa(); + 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.PostEffectFxaa constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnRenderImage(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PostEffectFxaa gen_to_be_invoked = (BF.PostEffectFxaa)translator.FastGetCSObj(L, 1); + + + + { + BF.PostEffectContext _context = (BF.PostEffectContext)translator.GetObject(L, 2, typeof(BF.PostEffectContext)); + + var gen_ret = gen_to_be_invoked.OnRenderImage( _context ); + 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_FxaaMaterial(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.PostEffectFxaa gen_to_be_invoked = (BF.PostEffectFxaa)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.FxaaMaterial); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_PostEffectRadialBlurWrap.cs b/Assets/XLua/Gen/BF_PostEffectRadialBlurWrap.cs new file mode 100644 index 000000000..cc613d640 --- /dev/null +++ b/Assets/XLua/Gen/BF_PostEffectRadialBlurWrap.cs @@ -0,0 +1,306 @@ +#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 BFPostEffectRadialBlurWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.PostEffectRadialBlur); + Utils.BeginObjectRegister(type, L, translator, 0, 5, 3, 2); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetBlurRadius", _m_SetBlurRadius); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshBlurRadius", _m_RefreshBlurRadius); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRadialCenter", _m_SetRadialCenter); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshRadialCenter", _m_RefreshRadialCenter); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRenderImage", _m_OnRenderImage); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "RadialBlurMaterial", _g_get_RadialBlurMaterial); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "BlurRadius", _g_get_BlurRadius); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "RadialCenter", _g_get_RadialCenter); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "BlurRadius", _s_set_BlurRadius); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "RadialCenter", _s_set_RadialCenter); + + + 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.PostEffectRadialBlur(); + 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.PostEffectRadialBlur constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetBlurRadius(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PostEffectRadialBlur gen_to_be_invoked = (BF.PostEffectRadialBlur)translator.FastGetCSObj(L, 1); + + + + { + float _blurRadius = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.SetBlurRadius( _blurRadius ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RefreshBlurRadius(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PostEffectRadialBlur gen_to_be_invoked = (BF.PostEffectRadialBlur)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RefreshBlurRadius( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRadialCenter(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PostEffectRadialBlur gen_to_be_invoked = (BF.PostEffectRadialBlur)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector2 _value;translator.Get(L, 2, out _value); + + gen_to_be_invoked.SetRadialCenter( _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RefreshRadialCenter(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PostEffectRadialBlur gen_to_be_invoked = (BF.PostEffectRadialBlur)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RefreshRadialCenter( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnRenderImage(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PostEffectRadialBlur gen_to_be_invoked = (BF.PostEffectRadialBlur)translator.FastGetCSObj(L, 1); + + + + { + BF.PostEffectContext _context = (BF.PostEffectContext)translator.GetObject(L, 2, typeof(BF.PostEffectContext)); + + var gen_ret = gen_to_be_invoked.OnRenderImage( _context ); + 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_RadialBlurMaterial(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.PostEffectRadialBlur gen_to_be_invoked = (BF.PostEffectRadialBlur)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.RadialBlurMaterial); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_BlurRadius(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.PostEffectRadialBlur gen_to_be_invoked = (BF.PostEffectRadialBlur)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.BlurRadius); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_RadialCenter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.PostEffectRadialBlur gen_to_be_invoked = (BF.PostEffectRadialBlur)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.RadialCenter); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_BlurRadius(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.PostEffectRadialBlur gen_to_be_invoked = (BF.PostEffectRadialBlur)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.BlurRadius = (float)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_RadialCenter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.PostEffectRadialBlur gen_to_be_invoked = (BF.PostEffectRadialBlur)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.RadialCenter = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_PostEffectVividBloomWrap.cs b/Assets/XLua/Gen/BF_PostEffectVividBloomWrap.cs new file mode 100644 index 000000000..64a606d38 --- /dev/null +++ b/Assets/XLua/Gen/BF_PostEffectVividBloomWrap.cs @@ -0,0 +1,427 @@ +#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 BFPostEffectVividBloomWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.PostEffectVividBloom); + Utils.BeginObjectRegister(type, L, translator, 0, 7, 4, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetIntensity", _m_SetIntensity); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetIterations", _m_SetIterations); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetThreshold", _m_SetThreshold); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSoftThreshold", _m_SetSoftThreshold); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshFilter", _m_RefreshFilter); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshIntensity", _m_RefreshIntensity); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRenderImage", _m_OnRenderImage); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Intensity", _g_get_Intensity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Iterations", _g_get_Iterations); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Threshold", _g_get_Threshold); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "SoftThreshold", _g_get_SoftThreshold); + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 3, 3); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "FilterID", _g_get_FilterID); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "IntensityID", _g_get_IntensityID); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "SourceTexID", _g_get_SourceTexID); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "FilterID", _s_set_FilterID); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "IntensityID", _s_set_IntensityID); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "SourceTexID", _s_set_SourceTexID); + + + 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.PostEffectVividBloom(); + 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.PostEffectVividBloom constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetIntensity(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PostEffectVividBloom gen_to_be_invoked = (BF.PostEffectVividBloom)translator.FastGetCSObj(L, 1); + + + + { + float _value = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.SetIntensity( _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetIterations(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PostEffectVividBloom gen_to_be_invoked = (BF.PostEffectVividBloom)translator.FastGetCSObj(L, 1); + + + + { + int _value = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetIterations( _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetThreshold(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PostEffectVividBloom gen_to_be_invoked = (BF.PostEffectVividBloom)translator.FastGetCSObj(L, 1); + + + + { + float _value = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.SetThreshold( _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSoftThreshold(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PostEffectVividBloom gen_to_be_invoked = (BF.PostEffectVividBloom)translator.FastGetCSObj(L, 1); + + + + { + float _value = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.SetSoftThreshold( _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RefreshFilter(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PostEffectVividBloom gen_to_be_invoked = (BF.PostEffectVividBloom)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RefreshFilter( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RefreshIntensity(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PostEffectVividBloom gen_to_be_invoked = (BF.PostEffectVividBloom)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RefreshIntensity( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnRenderImage(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PostEffectVividBloom gen_to_be_invoked = (BF.PostEffectVividBloom)translator.FastGetCSObj(L, 1); + + + + { + BF.PostEffectContext _context = (BF.PostEffectContext)translator.GetObject(L, 2, typeof(BF.PostEffectContext)); + + var gen_ret = gen_to_be_invoked.OnRenderImage( _context ); + 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_Intensity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.PostEffectVividBloom gen_to_be_invoked = (BF.PostEffectVividBloom)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.Intensity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Iterations(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.PostEffectVividBloom gen_to_be_invoked = (BF.PostEffectVividBloom)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Iterations); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Threshold(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.PostEffectVividBloom gen_to_be_invoked = (BF.PostEffectVividBloom)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.Threshold); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_SoftThreshold(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.PostEffectVividBloom gen_to_be_invoked = (BF.PostEffectVividBloom)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.SoftThreshold); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_FilterID(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, BF.PostEffectVividBloom.FilterID); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IntensityID(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, BF.PostEffectVividBloom.IntensityID); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_SourceTexID(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, BF.PostEffectVividBloom.SourceTexID); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_FilterID(RealStatePtr L) + { + try { + + BF.PostEffectVividBloom.FilterID = LuaAPI.xlua_tointeger(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_IntensityID(RealStatePtr L) + { + try { + + BF.PostEffectVividBloom.IntensityID = LuaAPI.xlua_tointeger(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_SourceTexID(RealStatePtr L) + { + try { + + BF.PostEffectVividBloom.SourceTexID = LuaAPI.xlua_tointeger(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_PreCheckProcessorWrap.cs b/Assets/XLua/Gen/BF_PreCheckProcessorWrap.cs new file mode 100644 index 000000000..c01a59196 --- /dev/null +++ b/Assets/XLua/Gen/BF_PreCheckProcessorWrap.cs @@ -0,0 +1,114 @@ +#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 BFPreCheckProcessorWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.PreCheckProcessor); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Process", _m_Process); + + + + + + 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) == 2 && translator.Assignable(L, 2)) + { + BF.GameLaunchProcessorBase _nextProcessor = (BF.GameLaunchProcessorBase)translator.GetObject(L, 2, typeof(BF.GameLaunchProcessorBase)); + + var gen_ret = new BF.PreCheckProcessor(_nextProcessor); + 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.PreCheckProcessor constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Process(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PreCheckProcessor gen_to_be_invoked = (BF.PreCheckProcessor)translator.FastGetCSObj(L, 1); + + + + { + BF.LaunchRequester _lr = (BF.LaunchRequester)translator.GetObject(L, 2, typeof(BF.LaunchRequester)); + + gen_to_be_invoked.Process( _lr ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_PrefabHelperWrap.cs b/Assets/XLua/Gen/BF_PrefabHelperWrap.cs new file mode 100644 index 000000000..4a41240dd --- /dev/null +++ b/Assets/XLua/Gen/BF_PrefabHelperWrap.cs @@ -0,0 +1,1442 @@ +#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 BFPrefabHelperWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.PrefabHelper); + Utils.BeginObjectRegister(type, L, translator, 0, 41, 5, 2); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetGameObjectByName", _m_GetGameObjectByName); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetListCount", _m_GetListCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashNameByIndex", _m_GetHashNameByIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetObjectTypeByIndex", _m_GetObjectTypeByIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetGameObjectByIndex", _m_GetGameObjectByIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CacheAnchoredPosition", _m_CacheAnchoredPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAnchoredPosition", _m_GetAnchoredPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAnchoredPositionX", _m_SetAnchoredPositionX); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAnchoredPositionY", _m_SetAnchoredPositionY); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAnchoredPosition", _m_SetAnchoredPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAnchorMin", _m_SetAnchorMin); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAnchorMax", _m_SetAnchorMax); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetOffsetMin", _m_SetOffsetMin); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetOffsetMax", _m_SetOffsetMax); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddAnchoredPosition", _m_AddAnchoredPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSizeDelta", _m_SetSizeDelta); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSizeDeltaX", _m_SetSizeDeltaX); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSizeDeltaY", _m_SetSizeDeltaY); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddSizeDelta", _m_AddSizeDelta); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSizeDelta", _m_GetSizeDelta); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CacheSizeDelt", _m_CacheSizeDelt); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetRectWidth", _m_GetRectWidth); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetRectHeight", _m_GetRectHeight); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPosition", _m_SetPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddPosition", _m_AddPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLocalPosition", _m_SetLocalPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLocalPositionX", _m_SetLocalPositionX); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLocalPositionY", _m_SetLocalPositionY); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddLocalPosition", _m_AddLocalPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CacheLocalPosition", _m_CacheLocalPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CachePosition", _m_CachePosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CacheLocalScale", _m_CacheLocalScale); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetEulerAngles", _m_SetEulerAngles); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddEulerAngles", _m_AddEulerAngles); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLocalEulerAngles", _m_SetLocalEulerAngles); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddLocalEulerAngles", _m_AddLocalEulerAngles); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLocalScale", _m_SetLocalScale); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddLocalScale", _m_AddLocalScale); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetRootPrefabIndex", _m_GetRootPrefabIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetScrollRectCellName", _m_SetScrollRectCellName); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetlocalRotationZ", _m_GetlocalRotationZ); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PositionX", _g_get_PositionX); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PositionY", _g_get_PositionY); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PositionZ", _g_get_PositionZ); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lis_AddObject", _g_get_lis_AddObject); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "prefabList", _g_get_prefabList); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "lis_AddObject", _s_set_lis_AddObject); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "prefabList", _s_set_prefabList); + + + 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.PrefabHelper(); + 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.PrefabHelper constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetGameObjectByName(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetGameObjectByName( _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_GetListCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetListCount( ); + 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_GetHashNameByIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetHashNameByIndex( _index ); + LuaAPI.xlua_pushuint(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_GetObjectTypeByIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetObjectTypeByIndex( _index ); + 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_GetGameObjectByIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetGameObjectByIndex( _index ); + 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_CacheAnchoredPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.CacheAnchoredPosition( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetAnchoredPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetAnchoredPosition( _index ); + translator.PushUnityEngineVector3(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_SetAnchoredPositionX(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetAnchoredPositionX( _index, _x ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAnchoredPositionY(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetAnchoredPositionY( _index, _y ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAnchoredPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.SetAnchoredPosition( _index, _x, _y ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAnchorMin(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.SetAnchorMin( _index, _x, _y ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAnchorMax(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.SetAnchorMax( _index, _x, _y ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetOffsetMin(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.SetOffsetMin( _index, _x, _y ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetOffsetMax(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.SetOffsetMax( _index, _x, _y ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddAnchoredPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.AddAnchoredPosition( _index, _x, _y ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSizeDelta(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.SetSizeDelta( _index, _x, _y ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSizeDeltaX(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetSizeDeltaX( _index, _x ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSizeDeltaY(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetSizeDeltaY( _index, _y ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddSizeDelta(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.AddSizeDelta( _index, _x, _y ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetSizeDelta(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetSizeDelta( _index ); + translator.PushUnityEngineVector2(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_CacheSizeDelt(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.CacheSizeDelt( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetRectWidth(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetRectWidth( _index ); + LuaAPI.lua_pushnumber(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_GetRectHeight(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetRectHeight( _index ); + LuaAPI.lua_pushnumber(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_SetPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + float _z = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.SetPosition( _index, _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + float _z = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.AddPosition( _index, _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLocalPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + float _z = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.SetLocalPosition( _index, _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLocalPositionX(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetLocalPositionX( _index, _x ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLocalPositionY(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetLocalPositionY( _index, _y ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddLocalPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + float _z = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.AddLocalPosition( _index, _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CacheLocalPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.CacheLocalPosition( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CachePosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.CachePosition( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CacheLocalScale(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.CacheLocalScale( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetEulerAngles(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + float _z = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.SetEulerAngles( _index, _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddEulerAngles(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + float _z = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.AddEulerAngles( _index, _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLocalEulerAngles(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + float _z = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.SetLocalEulerAngles( _index, _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddLocalEulerAngles(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + float _z = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.AddLocalEulerAngles( _index, _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLocalScale(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + float _z = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.SetLocalScale( _index, _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddLocalScale(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + float _z = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.AddLocalScale( _index, _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetRootPrefabIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetRootPrefabIndex( ); + 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_SetScrollRectCellName(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _nameIndex = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetScrollRectCellName( _index, _nameIndex ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetlocalRotationZ(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetlocalRotationZ( _index ); + LuaAPI.lua_pushnumber(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_PositionX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.PositionX); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PositionY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.PositionY); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PositionZ(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.PositionZ); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lis_AddObject(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.lis_AddObject); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_prefabList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.prefabList); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_lis_AddObject(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.lis_AddObject = (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; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_prefabList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.PrefabHelper gen_to_be_invoked = (BF.PrefabHelper)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.prefabList = (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/BF_PrepareProcessorWrap.cs b/Assets/XLua/Gen/BF_PrepareProcessorWrap.cs new file mode 100644 index 000000000..d0bbd19b8 --- /dev/null +++ b/Assets/XLua/Gen/BF_PrepareProcessorWrap.cs @@ -0,0 +1,114 @@ +#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 BFPrepareProcessorWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.PrepareProcessor); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Process", _m_Process); + + + + + + 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) == 2 && translator.Assignable(L, 2)) + { + BF.GameLaunchProcessorBase _nextProcessor = (BF.GameLaunchProcessorBase)translator.GetObject(L, 2, typeof(BF.GameLaunchProcessorBase)); + + var gen_ret = new BF.PrepareProcessor(_nextProcessor); + 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.PrepareProcessor constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Process(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.PrepareProcessor gen_to_be_invoked = (BF.PrepareProcessor)translator.FastGetCSObj(L, 1); + + + + { + BF.LaunchRequester _lr = (BF.LaunchRequester)translator.GetObject(L, 2, typeof(BF.LaunchRequester)); + + gen_to_be_invoked.Process( _lr ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_RawImageGridWrap.cs b/Assets/XLua/Gen/BF_RawImageGridWrap.cs new file mode 100644 index 000000000..8b7da8c11 --- /dev/null +++ b/Assets/XLua/Gen/BF_RawImageGridWrap.cs @@ -0,0 +1,146 @@ +#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 BFRawImageGridWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.RawImageGrid); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 2); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "paddingTopSlice", _g_get_paddingTopSlice); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "paddingBottomSlice", _g_get_paddingBottomSlice); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "paddingTopSlice", _s_set_paddingTopSlice); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "paddingBottomSlice", _s_set_paddingBottomSlice); + + + 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.RawImageGrid(); + 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.RawImageGrid constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_paddingTopSlice(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.RawImageGrid gen_to_be_invoked = (BF.RawImageGrid)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.paddingTopSlice); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_paddingBottomSlice(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.RawImageGrid gen_to_be_invoked = (BF.RawImageGrid)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.paddingBottomSlice); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_paddingTopSlice(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.RawImageGrid gen_to_be_invoked = (BF.RawImageGrid)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.paddingTopSlice = (float)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_paddingBottomSlice(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.RawImageGrid gen_to_be_invoked = (BF.RawImageGrid)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.paddingBottomSlice = (float)LuaAPI.lua_tonumber(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_Rc4EncryptWrap.cs b/Assets/XLua/Gen/BF_Rc4EncryptWrap.cs new file mode 100644 index 000000000..284bd89e0 --- /dev/null +++ b/Assets/XLua/Gen/BF_Rc4EncryptWrap.cs @@ -0,0 +1,220 @@ +#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 BFRc4EncryptWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.Rc4Encrypt); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 0, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "EncryptBytes", _m_EncryptBytes); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DecryptBytes", _m_DecryptBytes); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "EncryptStr", _m_EncryptStr); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DecryptStr", _m_DecryptStr); + + + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Key", _s_set_Key); + + + 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.Rc4Encrypt(); + 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.Rc4Encrypt constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_EncryptBytes(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.Rc4Encrypt gen_to_be_invoked = (BF.Rc4Encrypt)translator.FastGetCSObj(L, 1); + + + + { + byte[] _bytes = LuaAPI.lua_tobytes(L, 2); + + var gen_ret = gen_to_be_invoked.EncryptBytes( _bytes ); + 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 _m_DecryptBytes(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.Rc4Encrypt gen_to_be_invoked = (BF.Rc4Encrypt)translator.FastGetCSObj(L, 1); + + + + { + byte[] _bytes = LuaAPI.lua_tobytes(L, 2); + + var gen_ret = gen_to_be_invoked.DecryptBytes( _bytes ); + 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 _m_EncryptStr(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.Rc4Encrypt gen_to_be_invoked = (BF.Rc4Encrypt)translator.FastGetCSObj(L, 1); + + + + { + string _data = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.EncryptStr( _data ); + 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 _m_DecryptStr(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.Rc4Encrypt gen_to_be_invoked = (BF.Rc4Encrypt)translator.FastGetCSObj(L, 1); + + + + { + string _data = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.DecryptStr( _data ); + 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 _s_set_Key(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.Rc4Encrypt gen_to_be_invoked = (BF.Rc4Encrypt)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Key = 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/BF_Rc4ObjectWrap.cs b/Assets/XLua/Gen/BF_Rc4ObjectWrap.cs new file mode 100644 index 000000000..8ac808d9b --- /dev/null +++ b/Assets/XLua/Gen/BF_Rc4ObjectWrap.cs @@ -0,0 +1,146 @@ +#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 BFRc4ObjectWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.Rc4Object); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 2); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "key", _g_get_key); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "value", _g_get_value); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "key", _s_set_key); + 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) == 1) + { + + var gen_ret = new BF.Rc4Object(); + 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.Rc4Object constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_key(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.Rc4Object gen_to_be_invoked = (BF.Rc4Object)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.key); + } 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); + + BF.Rc4Object gen_to_be_invoked = (BF.Rc4Object)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_key(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.Rc4Object gen_to_be_invoked = (BF.Rc4Object)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.key = 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); + + BF.Rc4Object gen_to_be_invoked = (BF.Rc4Object)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/BF_RenderManagerWrap.cs b/Assets/XLua/Gen/BF_RenderManagerWrap.cs new file mode 100644 index 000000000..66bdcb0f6 --- /dev/null +++ b/Assets/XLua/Gen/BF_RenderManagerWrap.cs @@ -0,0 +1,914 @@ +#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 BFRenderManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.RenderManager); + Utils.BeginObjectRegister(type, L, translator, 0, 18, 12, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetUIDefaultMat", _m_SetUIDefaultMat); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetUITutorialMat", _m_SetUITutorialMat); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetBlurMat", _m_SetBlurMat); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetBloomMat", _m_SetBloomMat); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetBlitCopyMat", _m_SetBlitCopyMat); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetVividBloomMat", _m_SetVividBloomMat); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetFxaaMat", _m_SetFxaaMat); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRadialBlur", _m_SetRadialBlur); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMeshOutlineMaskMat", _m_SetMeshOutlineMaskMat); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMeshOutlineFillMat", _m_SetMeshOutlineFillMat); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetGrey", _m_SetGrey); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetBlurBg", _m_GetBlurBg); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetBlurBgWithBloom", _m_GetBlurBgWithBloom); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetScreenShot", _m_GetScreenShot); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OpenPostEffect", _m_OpenPostEffect); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClosePostEffect", _m_ClosePostEffect); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Destroy", _m_Destroy); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "BlurSizeID", _g_get_BlurSizeID); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "BloomID", _g_get_BloomID); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "UIDefaultMat", _g_get_UIDefaultMat); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "UITutorialMat", _g_get_UITutorialMat); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "BlurMat", _g_get_BlurMat); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "BloomMat", _g_get_BloomMat); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "VividBloomMat", _g_get_VividBloomMat); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "BlitCopyMat", _g_get_BlitCopyMat); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "FxaaMat", _g_get_FxaaMat); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "RadialBlurMat", _g_get_RadialBlurMat); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "MeshOutlineMaskMat", _g_get_MeshOutlineMaskMat); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "MeshOutlineFillMat", _g_get_MeshOutlineFillMat); + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Create", _m_Create_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "BF.RenderManager does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Create_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = BF.RenderManager.Create( ); + 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_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetUIDefaultMat(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + gen_to_be_invoked.SetUIDefaultMat( _material ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetUITutorialMat(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + gen_to_be_invoked.SetUITutorialMat( _material ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetBlurMat(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + gen_to_be_invoked.SetBlurMat( _material ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetBloomMat(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + gen_to_be_invoked.SetBloomMat( _material ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetBlitCopyMat(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + gen_to_be_invoked.SetBlitCopyMat( _material ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetVividBloomMat(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + gen_to_be_invoked.SetVividBloomMat( _material ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetFxaaMat(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + gen_to_be_invoked.SetFxaaMat( _material ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRadialBlur(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + gen_to_be_invoked.SetRadialBlur( _material ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMeshOutlineMaskMat(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + gen_to_be_invoked.SetMeshOutlineMaskMat( _material ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMeshOutlineFillMat(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + gen_to_be_invoked.SetMeshOutlineFillMat( _material ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetGrey(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.UI.MaskableGraphic _mg = (UnityEngine.UI.MaskableGraphic)translator.GetObject(L, 2, typeof(UnityEngine.UI.MaskableGraphic)); + bool _isGrey = LuaAPI.lua_toboolean(L, 3); + byte _greyLv = (byte)LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.SetGrey( _mg, _isGrey, _greyLv ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + UnityEngine.UI.MaskableGraphic _mg = (UnityEngine.UI.MaskableGraphic)translator.GetObject(L, 2, typeof(UnityEngine.UI.MaskableGraphic)); + bool _isGrey = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.SetGrey( _mg, _isGrey ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.RenderManager.SetGrey!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetBlurBg(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Camera[] _targetCameras = (UnityEngine.Camera[])translator.GetObject(L, 2, typeof(UnityEngine.Camera[])); + int _width = LuaAPI.xlua_tointeger(L, 3); + int _height = LuaAPI.xlua_tointeger(L, 4); + int _iteration = LuaAPI.xlua_tointeger(L, 5); + + var gen_ret = gen_to_be_invoked.GetBlurBg( _targetCameras, _width, _height, _iteration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Camera[] _targetCameras = (UnityEngine.Camera[])translator.GetObject(L, 2, typeof(UnityEngine.Camera[])); + int _width = LuaAPI.xlua_tointeger(L, 3); + int _height = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.GetBlurBg( _targetCameras, _width, _height ); + 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.RenderManager.GetBlurBg!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetBlurBgWithBloom(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Camera[] _targetCameras = (UnityEngine.Camera[])translator.GetObject(L, 2, typeof(UnityEngine.Camera[])); + int _width = LuaAPI.xlua_tointeger(L, 3); + int _height = LuaAPI.xlua_tointeger(L, 4); + int _iteration = LuaAPI.xlua_tointeger(L, 5); + + var gen_ret = gen_to_be_invoked.GetBlurBgWithBloom( _targetCameras, _width, _height, _iteration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Camera[] _targetCameras = (UnityEngine.Camera[])translator.GetObject(L, 2, typeof(UnityEngine.Camera[])); + int _width = LuaAPI.xlua_tointeger(L, 3); + int _height = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.GetBlurBgWithBloom( _targetCameras, _width, _height ); + 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.RenderManager.GetBlurBgWithBloom!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetScreenShot(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Action _onTexture = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.GetScreenShot( _onTexture ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Camera[] _targetCameras = (UnityEngine.Camera[])translator.GetObject(L, 2, typeof(UnityEngine.Camera[])); + + var gen_ret = gen_to_be_invoked.GetScreenShot( _targetCameras ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Camera[] _targetCameras = (UnityEngine.Camera[])translator.GetObject(L, 2, typeof(UnityEngine.Camera[])); + UnityEngine.Rect _rect;translator.Get(L, 3, out _rect); + + var gen_ret = gen_to_be_invoked.GetScreenShot( _targetCameras, _rect ); + 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.RenderManager.GetScreenShot!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OpenPostEffect(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _effectType = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 3, typeof(UnityEngine.Camera)); + + var gen_ret = gen_to_be_invoked.OpenPostEffect( _effectType, _camera ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + BF.PostEffectType _effectType;translator.Get(L, 2, out _effectType); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 3, typeof(UnityEngine.Camera)); + + var gen_ret = gen_to_be_invoked.OpenPostEffect( _effectType, _camera ); + 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.RenderManager.OpenPostEffect!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClosePostEffect(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _effectType = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 3, typeof(UnityEngine.Camera)); + + gen_to_be_invoked.ClosePostEffect( _effectType, _camera ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + BF.PostEffectType _effectType;translator.Get(L, 2, out _effectType); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 3, typeof(UnityEngine.Camera)); + + gen_to_be_invoked.ClosePostEffect( _effectType, _camera ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.RenderManager.ClosePostEffect!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Destroy(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Destroy( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_BlurSizeID(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.BlurSizeID); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_BloomID(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.BloomID); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UIDefaultMat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.UIDefaultMat); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UITutorialMat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.UITutorialMat); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_BlurMat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.BlurMat); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_BloomMat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.BloomMat); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_VividBloomMat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.VividBloomMat); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_BlitCopyMat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.BlitCopyMat); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_FxaaMat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.FxaaMat); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_RadialBlurMat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.RadialBlurMat); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_MeshOutlineMaskMat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.MeshOutlineMaskMat); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_MeshOutlineFillMat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.RenderManager gen_to_be_invoked = (BF.RenderManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.MeshOutlineFillMat); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_RequestLoginCenterConfigProcessorWrap.cs b/Assets/XLua/Gen/BF_RequestLoginCenterConfigProcessorWrap.cs new file mode 100644 index 000000000..b7deecffa --- /dev/null +++ b/Assets/XLua/Gen/BF_RequestLoginCenterConfigProcessorWrap.cs @@ -0,0 +1,114 @@ +#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 BFRequestLoginCenterConfigProcessorWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.RequestLoginCenterConfigProcessor); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Process", _m_Process); + + + + + + 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) == 2 && translator.Assignable(L, 2)) + { + BF.GameLaunchProcessorBase _nextProcessor = (BF.GameLaunchProcessorBase)translator.GetObject(L, 2, typeof(BF.GameLaunchProcessorBase)); + + var gen_ret = new BF.RequestLoginCenterConfigProcessor(_nextProcessor); + 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.RequestLoginCenterConfigProcessor constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Process(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.RequestLoginCenterConfigProcessor gen_to_be_invoked = (BF.RequestLoginCenterConfigProcessor)translator.FastGetCSObj(L, 1); + + + + { + BF.LaunchRequester _lr = (BF.LaunchRequester)translator.GetObject(L, 2, typeof(BF.LaunchRequester)); + + gen_to_be_invoked.Process( _lr ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_RequestVersionProcessorWrap.cs b/Assets/XLua/Gen/BF_RequestVersionProcessorWrap.cs new file mode 100644 index 000000000..3a554f4e6 --- /dev/null +++ b/Assets/XLua/Gen/BF_RequestVersionProcessorWrap.cs @@ -0,0 +1,114 @@ +#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 BFRequestVersionProcessorWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.RequestVersionProcessor); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Process", _m_Process); + + + + + + 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) == 2 && translator.Assignable(L, 2)) + { + BF.GameLaunchProcessorBase _nextProcessor = (BF.GameLaunchProcessorBase)translator.GetObject(L, 2, typeof(BF.GameLaunchProcessorBase)); + + var gen_ret = new BF.RequestVersionProcessor(_nextProcessor); + 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.RequestVersionProcessor constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Process(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.RequestVersionProcessor gen_to_be_invoked = (BF.RequestVersionProcessor)translator.FastGetCSObj(L, 1); + + + + { + BF.LaunchRequester _lr = (BF.LaunchRequester)translator.GetObject(L, 2, typeof(BF.LaunchRequester)); + + gen_to_be_invoked.Process( _lr ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_ResourceManagerWrap.cs b/Assets/XLua/Gen/BF_ResourceManagerWrap.cs new file mode 100644 index 000000000..5149f6c6d --- /dev/null +++ b/Assets/XLua/Gen/BF_ResourceManagerWrap.cs @@ -0,0 +1,579 @@ +#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 BFResourceManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.ResourceManager); + Utils.BeginObjectRegister(type, L, translator, 0, 15, 2, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Destroy", _m_Destroy); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAbConfigCollection", _m_SetAbConfigCollection); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ReloadManifest", _m_ReloadManifest); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadAsync", _m_LoadAsync); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadSync", _m_LoadSync); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Unload", _m_Unload); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveAsset", _m_RemoveAsset); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnloadAllDelayAssets", _m_UnloadAllDelayAssets); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSceneLoadPath", _m_GetSceneLoadPath); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadSceneAsync", _m_LoadSceneAsync); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnloadScene", _m_UnloadScene); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ContainsAsset", _m_ContainsAsset); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Update", _m_Update); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AbConfigCollection", _g_get_AbConfigCollection); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Manifest", _g_get_Manifest); + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 4, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Create", _m_Create_xlua_st_); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TIME_OUT_LOAD", BF.ResourceManager.TIME_OUT_LOAD); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TIME_DELAY_UNLOAD", BF.ResourceManager.TIME_DELAY_UNLOAD); + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "BF.ResourceManager does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Create_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = BF.ResourceManager.Create( ); + 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_Destroy(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ResourceManager gen_to_be_invoked = (BF.ResourceManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Destroy( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Clear(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ResourceManager gen_to_be_invoked = (BF.ResourceManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Clear( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ResourceManager gen_to_be_invoked = (BF.ResourceManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAbConfigCollection(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ResourceManager gen_to_be_invoked = (BF.ResourceManager)translator.FastGetCSObj(L, 1); + + + + { + BF.AssetBundleConfigCollection _abcc = (BF.AssetBundleConfigCollection)translator.GetObject(L, 2, typeof(BF.AssetBundleConfigCollection)); + + gen_to_be_invoked.SetAbConfigCollection( _abcc ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ReloadManifest(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ResourceManager gen_to_be_invoked = (BF.ResourceManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ReloadManifest( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadAsync(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ResourceManager gen_to_be_invoked = (BF.ResourceManager)translator.FastGetCSObj(L, 1); + + + + { + string _assetPath = LuaAPI.lua_tostring(L, 2); + System.Type _type = (System.Type)translator.GetObject(L, 3, typeof(System.Type)); + System.Action _complete = translator.GetDelegate>(L, 4); + + var gen_ret = gen_to_be_invoked.LoadAsync( _assetPath, _type, _complete ); + LuaAPI.xlua_pushuint(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_LoadSync(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ResourceManager gen_to_be_invoked = (BF.ResourceManager)translator.FastGetCSObj(L, 1); + + + + { + string _assetPath = LuaAPI.lua_tostring(L, 2); + System.Type _type = (System.Type)translator.GetObject(L, 3, typeof(System.Type)); + + var gen_ret = gen_to_be_invoked.LoadSync( _assetPath, _type ); + 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_Unload(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ResourceManager gen_to_be_invoked = (BF.ResourceManager)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + string _assetPath = LuaAPI.lua_tostring(L, 2); + bool _immediately = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.Unload( _assetPath, _immediately ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + BF.AssetObject _assetObject = (BF.AssetObject)translator.GetObject(L, 2, typeof(BF.AssetObject)); + bool _immediately = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.Unload( _assetObject, _immediately ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.ResourceManager.Unload!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveAsset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ResourceManager gen_to_be_invoked = (BF.ResourceManager)translator.FastGetCSObj(L, 1); + + + + { + string _assetPath = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.RemoveAsset( _assetPath ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UnloadAllDelayAssets(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ResourceManager gen_to_be_invoked = (BF.ResourceManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.UnloadAllDelayAssets( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetSceneLoadPath(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ResourceManager gen_to_be_invoked = (BF.ResourceManager)translator.FastGetCSObj(L, 1); + + + + { + string _assetBundlePath = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetSceneLoadPath( _assetBundlePath ); + 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 _m_LoadSceneAsync(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ResourceManager gen_to_be_invoked = (BF.ResourceManager)translator.FastGetCSObj(L, 1); + + + + { + string _assetBundlePath = LuaAPI.lua_tostring(L, 2); + System.Action _complete = translator.GetDelegate>(L, 3); + + gen_to_be_invoked.LoadSceneAsync( _assetBundlePath, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UnloadScene(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ResourceManager gen_to_be_invoked = (BF.ResourceManager)translator.FastGetCSObj(L, 1); + + + + { + string _assetBundlePath = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.UnloadScene( _assetBundlePath ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ContainsAsset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ResourceManager gen_to_be_invoked = (BF.ResourceManager)translator.FastGetCSObj(L, 1); + + + + { + string _assetPath = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.ContainsAsset( _assetPath ); + 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_Update(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ResourceManager gen_to_be_invoked = (BF.ResourceManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Update( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AbConfigCollection(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ResourceManager gen_to_be_invoked = (BF.ResourceManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.AbConfigCollection); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Manifest(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ResourceManager gen_to_be_invoked = (BF.ResourceManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Manifest); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_ResourcesProtectWrap.cs b/Assets/XLua/Gen/BF_ResourcesProtectWrap.cs new file mode 100644 index 000000000..9b9c2349d --- /dev/null +++ b/Assets/XLua/Gen/BF_ResourcesProtectWrap.cs @@ -0,0 +1,282 @@ +#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 BFResourcesProtectWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.ResourcesProtect); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 7, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "DoEncrypt", _m_DoEncrypt_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "DoDecrypt", _m_DoDecrypt_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Read", _m_Read_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Write", _m_Write_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ExecuteEncrypt", _m_ExecuteEncrypt_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ExecuteDecrypt", _m_ExecuteDecrypt_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 BF.ResourcesProtect(); + 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.ResourcesProtect constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DoEncrypt_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (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)&& translator.Assignable>(L, 4)) + { + string _resPath = LuaAPI.lua_tostring(L, 1); + string _key = LuaAPI.lua_tostring(L, 2); + string _desPath = LuaAPI.lua_tostring(L, 3); + System.Func _filter = translator.GetDelegate>(L, 4); + + BF.ResourcesProtect.DoEncrypt( _resPath, _key, _desPath, _filter ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (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 _resPath = LuaAPI.lua_tostring(L, 1); + string _key = LuaAPI.lua_tostring(L, 2); + string _desPath = LuaAPI.lua_tostring(L, 3); + + BF.ResourcesProtect.DoEncrypt( _resPath, _key, _desPath ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.ResourcesProtect.DoEncrypt!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DoDecrypt_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (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)&& translator.Assignable>(L, 4)) + { + string _resPath = LuaAPI.lua_tostring(L, 1); + string _key = LuaAPI.lua_tostring(L, 2); + string _desPath = LuaAPI.lua_tostring(L, 3); + System.Func _filter = translator.GetDelegate>(L, 4); + + BF.ResourcesProtect.DoDecrypt( _resPath, _key, _desPath, _filter ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (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 _resPath = LuaAPI.lua_tostring(L, 1); + string _key = LuaAPI.lua_tostring(L, 2); + string _desPath = LuaAPI.lua_tostring(L, 3); + + BF.ResourcesProtect.DoDecrypt( _resPath, _key, _desPath ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.ResourcesProtect.DoDecrypt!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Read_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _resPath = LuaAPI.lua_tostring(L, 1); + + var gen_ret = BF.ResourcesProtect.Read( _resPath ); + 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 _m_Write_xlua_st_(RealStatePtr L) + { + try { + + + + + { + byte[] _buffer = LuaAPI.lua_tobytes(L, 1); + string _resPath = LuaAPI.lua_tostring(L, 2); + + BF.ResourcesProtect.Write( _buffer, _resPath ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ExecuteEncrypt_xlua_st_(RealStatePtr L) + { + try { + + + + + { + byte[] _buffer = LuaAPI.lua_tobytes(L, 1); + string _key = LuaAPI.lua_tostring(L, 2); + + var gen_ret = BF.ResourcesProtect.ExecuteEncrypt( _buffer, _key ); + 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 _m_ExecuteDecrypt_xlua_st_(RealStatePtr L) + { + try { + + + + + { + byte[] _buffer = LuaAPI.lua_tobytes(L, 1); + string _key = LuaAPI.lua_tostring(L, 2); + + var gen_ret = BF.ResourcesProtect.ExecuteDecrypt( _buffer, _key ); + 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/BF_RsaEncryptWrap.cs b/Assets/XLua/Gen/BF_RsaEncryptWrap.cs new file mode 100644 index 000000000..66f989e45 --- /dev/null +++ b/Assets/XLua/Gen/BF_RsaEncryptWrap.cs @@ -0,0 +1,200 @@ +#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 BFRsaEncryptWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.RsaEncrypt); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 4, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Encrypt", _m_Encrypt_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Decrypt", _m_Decrypt_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ConvertFromPemPublicKey", _m_ConvertFromPemPublicKey_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 BF.RsaEncrypt(); + 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.RsaEncrypt constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Encrypt_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + string _key = LuaAPI.lua_tostring(L, 1); + string _value = LuaAPI.lua_tostring(L, 2); + bool _tobase64 = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = BF.RsaEncrypt.Encrypt( _key, _value, _tobase64 ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _key = LuaAPI.lua_tostring(L, 1); + string _value = LuaAPI.lua_tostring(L, 2); + + var gen_ret = BF.RsaEncrypt.Encrypt( _key, _value ); + LuaAPI.lua_pushstring(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.RsaEncrypt.Encrypt!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Decrypt_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + string _key = LuaAPI.lua_tostring(L, 1); + string _value = LuaAPI.lua_tostring(L, 2); + bool _frombase64 = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = BF.RsaEncrypt.Decrypt( _key, _value, _frombase64 ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _key = LuaAPI.lua_tostring(L, 1); + string _value = LuaAPI.lua_tostring(L, 2); + + var gen_ret = BF.RsaEncrypt.Decrypt( _key, _value ); + LuaAPI.lua_pushstring(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.RsaEncrypt.Decrypt!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ConvertFromPemPublicKey_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _pemFileConent = LuaAPI.lua_tostring(L, 1); + + var gen_ret = BF.RsaEncrypt.ConvertFromPemPublicKey( _pemFileConent ); + 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/BF_SDKManagerWrap.cs b/Assets/XLua/Gen/BF_SDKManagerWrap.cs new file mode 100644 index 000000000..3e2c7b505 --- /dev/null +++ b/Assets/XLua/Gen/BF_SDKManagerWrap.cs @@ -0,0 +1,343 @@ +#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 BFSDKManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.SDKManager); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 9, 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.GETTER_IDX, "BFLoginSDKMgr", _g_get_BFLoginSDKMgr); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "BFPaySDKMgr", _g_get_BFPaySDKMgr); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "BFRuPaySDKMgr", _g_get_BFRuPaySDKMgr); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "BFHWPaySDKMgr", _g_get_BFHWPaySDKMgr); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IosPaySDKMgr", _g_get_IosPaySDKMgr); + 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, "NotificationSDKMgr", _g_get_NotificationSDKMgr); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "DeepLinkMgr", _g_get_DeepLinkMgr); + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Create", _m_Create_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "BF.SDKManager does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Create_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = BF.SDKManager.Create( ); + 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_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SDKManager gen_to_be_invoked = (BF.SDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Destroy(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SDKManager gen_to_be_invoked = (BF.SDKManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Destroy( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetLanguage(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.GetLanguage( ); + 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 _m_GetTimeZone(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.GetTimeZone( ); + 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_BFLoginSDKMgr(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.BFLoginSDKMgr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_BFPaySDKMgr(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.BFPaySDKMgr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_BFRuPaySDKMgr(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.BFRuPaySDKMgr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_BFHWPaySDKMgr(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.BFHWPaySDKMgr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IosPaySDKMgr(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.IosPaySDKMgr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_BFNativeSDKMgr(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.BFNativeSDKMgr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_BFThirdReportSDKMgr(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.BFThirdReportSDKMgr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_NotificationSDKMgr(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.NotificationSDKMgr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DeepLinkMgr(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.DeepLinkMgr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_SafeAreaManagerWrap.cs b/Assets/XLua/Gen/BF_SafeAreaManagerWrap.cs new file mode 100644 index 000000000..1b40c10b0 --- /dev/null +++ b/Assets/XLua/Gen/BF_SafeAreaManagerWrap.cs @@ -0,0 +1,149 @@ +#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 BFSafeAreaManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.SafeAreaManager); + 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, 1, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetSafeArea", _m_GetSafeArea_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetNotchScreenHeight", _m_GetNotchScreenHeight_xlua_st_); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "Instance", _g_get_Instance); + + + + 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.SafeAreaManager(); + 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.SafeAreaManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetSafeArea_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = BF.SafeAreaManager.GetSafeArea( ); + 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_GetNotchScreenHeight_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.SafeAreaManager.GetNotchScreenHeight( ); + LuaAPI.lua_pushnumber(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_Instance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, BF.SafeAreaManager.Instance); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_ScrollRectBaseOldWrap.cs b/Assets/XLua/Gen/BF_ScrollRectBaseOldWrap.cs new file mode 100644 index 000000000..b741a80c3 --- /dev/null +++ b/Assets/XLua/Gen/BF_ScrollRectBaseOldWrap.cs @@ -0,0 +1,2061 @@ +#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 BFScrollRectBaseOldWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.ScrollRectBaseOld); + Utils.BeginObjectRegister(type, L, translator, 0, 34, 33, 26); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddOnvalueChangedFunc", _m_AddOnvalueChangedFunc); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddOnInstantiateCellAction", _m_AddOnInstantiateCellAction); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddRefreshAction", _m_AddRefreshAction); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddSetSelectedAction", _m_AddSetSelectedAction); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTotalCount", _m_SetTotalCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTotalCount", _m_GetTotalCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSelected", _m_SetSelected); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSelectedIndex", _m_GetSelectedIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddCell", _m_AddCell); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsNotFull", _m_IsNotFull); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveCell", _m_RemoveCell); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearCells", _m_ClearCells); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshRealShowIndex", _m_RefreshRealShowIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ScrollToCellImmediately", _m_ScrollToCellImmediately); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ScrollToCell", _m_ScrollToCell); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshAll", _m_RefreshAll); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefillCellsFromEnd", _m_RefillCellsFromEnd); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefiilCellsFromEndForFrame", _m_RefiilCellsFromEndForFrame); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefillCells", _m_RefillCells); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefillCellsForFrame", _m_RefillCellsForFrame); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Rebuild", _m_Rebuild); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LayoutComplete", _m_LayoutComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GraphicUpdateComplete", _m_GraphicUpdateComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsActive", _m_IsActive); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "StopMovement", _m_StopMovement); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnScroll", _m_OnScroll); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnInitializePotentialDrag", _m_OnInitializePotentialDrag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBeginDrag", _m_OnBeginDrag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnEndDrag", _m_OnEndDrag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnDrag", _m_OnDrag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CalculateLayoutInputHorizontal", _m_CalculateLayoutInputHorizontal); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CalculateLayoutInputVertical", _m_CalculateLayoutInputVertical); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLayoutHorizontal", _m_SetLayoutHorizontal); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLayoutVertical", _m_SetLayoutVertical); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "HorizontalScrollbar", _g_get_HorizontalScrollbar); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "VerticalScrollbar", _g_get_VerticalScrollbar); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "HorizontalScrollbarVisibility", _g_get_HorizontalScrollbarVisibility); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "VerticalScrollbarVisibility", _g_get_VerticalScrollbarVisibility); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "HorizontalScrollbarSpacing", _g_get_HorizontalScrollbarSpacing); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "VerticalScrollbarSpacing", _g_get_VerticalScrollbarSpacing); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "NormalizedPosition", _g_get_NormalizedPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "HorizontalNormalizedPosition", _g_get_HorizontalNormalizedPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "VerticalNormalizedPosition", _g_get_VerticalNormalizedPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "minWidth", _g_get_minWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preferredWidth", _g_get_preferredWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "flexibleWidth", _g_get_flexibleWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "minHeight", _g_get_minHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preferredHeight", _g_get_preferredHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "flexibleHeight", _g_get_flexibleHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "layoutPriority", _g_get_layoutPriority); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bfCell", _g_get_bfCell); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "useBar", _g_get_useBar); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rubberScale", _g_get_rubberScale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onValueChanged", _g_get_onValueChanged); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaInstantiateCellAction", _g_get_luaInstantiateCellAction); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaRefreshAction", _g_get_luaRefreshAction); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaSetSelectedAction", _g_get_luaSetSelectedAction); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "content", _g_get_content); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "horizontal", _g_get_horizontal); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "vertical", _g_get_vertical); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "movementType", _g_get_movementType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "elasticity", _g_get_elasticity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "inertia", _g_get_inertia); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "decelerationRate", _g_get_decelerationRate); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "scrollSensitivity", _g_get_scrollSensitivity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "viewport", _g_get_viewport); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "velocity", _g_get_velocity); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "HorizontalScrollbar", _s_set_HorizontalScrollbar); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "VerticalScrollbar", _s_set_VerticalScrollbar); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "HorizontalScrollbarVisibility", _s_set_HorizontalScrollbarVisibility); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "VerticalScrollbarVisibility", _s_set_VerticalScrollbarVisibility); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "HorizontalScrollbarSpacing", _s_set_HorizontalScrollbarSpacing); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "VerticalScrollbarSpacing", _s_set_VerticalScrollbarSpacing); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "NormalizedPosition", _s_set_NormalizedPosition); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "HorizontalNormalizedPosition", _s_set_HorizontalNormalizedPosition); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "VerticalNormalizedPosition", _s_set_VerticalNormalizedPosition); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "bfCell", _s_set_bfCell); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "useBar", _s_set_useBar); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "rubberScale", _s_set_rubberScale); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onValueChanged", _s_set_onValueChanged); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaInstantiateCellAction", _s_set_luaInstantiateCellAction); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaRefreshAction", _s_set_luaRefreshAction); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaSetSelectedAction", _s_set_luaSetSelectedAction); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "content", _s_set_content); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "horizontal", _s_set_horizontal); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "vertical", _s_set_vertical); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "movementType", _s_set_movementType); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "elasticity", _s_set_elasticity); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "inertia", _s_set_inertia); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "decelerationRate", _s_set_decelerationRate); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "scrollSensitivity", _s_set_scrollSensitivity); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "viewport", _s_set_viewport); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "velocity", _s_set_velocity); + + + 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, "BF.ScrollRectBaseOld does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddOnvalueChangedFunc(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + + { + System.Action _func = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.AddOnvalueChangedFunc( _func ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddOnInstantiateCellAction(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.AddOnInstantiateCellAction( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddRefreshAction(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.AddRefreshAction( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddSetSelectedAction(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.AddSetSelectedAction( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTotalCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + + { + int _count = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetTotalCount( _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetTotalCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetTotalCount( ); + 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_SetSelected(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetSelected( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetSelectedIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetSelectedIndex( ); + 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_AddCell(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.AddCell( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsNotFull(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsNotFull( ); + 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_RemoveCell(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + bool _alignFlag = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.RemoveCell( _index, _alignFlag ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.RemoveCell( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.ScrollRectBaseOld.RemoveCell!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearCells(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearCells( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RefreshRealShowIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RefreshRealShowIndex( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ScrollToCellImmediately(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + bool _alignFlag = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.ScrollToCellImmediately( _index, _alignFlag ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.ScrollToCellImmediately( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.ScrollRectBaseOld.ScrollToCellImmediately!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ScrollToCell(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _speed = (float)LuaAPI.lua_tonumber(L, 3); + bool _alignFlag = LuaAPI.lua_toboolean(L, 4); + + gen_to_be_invoked.ScrollToCell( _index, _speed, _alignFlag ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _speed = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.ScrollToCell( _index, _speed ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.ScrollRectBaseOld.ScrollToCell!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RefreshAll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RefreshAll( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RefillCellsFromEnd(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _offset = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.RefillCellsFromEnd( _offset ); + + + + return 0; + } + if(gen_param_count == 1) + { + + gen_to_be_invoked.RefillCellsFromEnd( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.ScrollRectBaseOld.RefillCellsFromEnd!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RefiilCellsFromEndForFrame(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _intervalFrame = LuaAPI.xlua_tointeger(L, 2); + int _offset = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.RefiilCellsFromEndForFrame( _intervalFrame, _offset ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _intervalFrame = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.RefiilCellsFromEndForFrame( _intervalFrame ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.ScrollRectBaseOld.RefiilCellsFromEndForFrame!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RefillCells(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.RefillCells( _index ); + + + + return 0; + } + if(gen_param_count == 1) + { + + gen_to_be_invoked.RefillCells( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.ScrollRectBaseOld.RefillCells!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RefillCellsForFrame(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _intervalFrame = LuaAPI.xlua_tointeger(L, 2); + int _index = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.RefillCellsForFrame( _intervalFrame, _index ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _intervalFrame = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.RefillCellsForFrame( _intervalFrame ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.ScrollRectBaseOld.RefillCellsForFrame!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Rebuild(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.UI.CanvasUpdate _executing;translator.Get(L, 2, out _executing); + + gen_to_be_invoked.Rebuild( _executing ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LayoutComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.LayoutComplete( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GraphicUpdateComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.GraphicUpdateComplete( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsActive(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsActive( ); + 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_StopMovement(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.StopMovement( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnScroll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _data = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnScroll( _data ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnInitializePotentialDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnInitializePotentialDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnBeginDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnBeginDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnEndDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnEndDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalculateLayoutInputHorizontal(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CalculateLayoutInputHorizontal( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalculateLayoutInputVertical(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CalculateLayoutInputVertical( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLayoutHorizontal(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetLayoutHorizontal( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLayoutVertical(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetLayoutVertical( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_HorizontalScrollbar(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.HorizontalScrollbar); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_VerticalScrollbar(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.VerticalScrollbar); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_HorizontalScrollbarVisibility(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + translator.PushBFScrollRectBaseOldScrollbarVisibility(L, gen_to_be_invoked.HorizontalScrollbarVisibility); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_VerticalScrollbarVisibility(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + translator.PushBFScrollRectBaseOldScrollbarVisibility(L, gen_to_be_invoked.VerticalScrollbarVisibility); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_HorizontalScrollbarSpacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.HorizontalScrollbarSpacing); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_VerticalScrollbarSpacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.VerticalScrollbarSpacing); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_NormalizedPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.NormalizedPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_HorizontalNormalizedPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.HorizontalNormalizedPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_VerticalNormalizedPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.VerticalNormalizedPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_minWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.minWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preferredWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.preferredWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_flexibleWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.flexibleWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_minHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.minHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preferredHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.preferredHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_flexibleHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.flexibleHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_layoutPriority(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.layoutPriority); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bfCell(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.bfCell); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_useBar(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.useBar); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rubberScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.rubberScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onValueChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onValueChanged); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaInstantiateCellAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaInstantiateCellAction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaRefreshAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaRefreshAction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaSetSelectedAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaSetSelectedAction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_content(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.content); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_horizontal(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.horizontal); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_vertical(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.vertical); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_movementType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + translator.PushBFScrollRectBaseOldMovementType(L, gen_to_be_invoked.movementType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_elasticity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.elasticity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_inertia(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.inertia); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_decelerationRate(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.decelerationRate); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_scrollSensitivity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.scrollSensitivity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_viewport(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.viewport); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_velocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.velocity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_HorizontalScrollbar(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.HorizontalScrollbar = (UnityEngine.UI.Scrollbar)translator.GetObject(L, 2, typeof(UnityEngine.UI.Scrollbar)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_VerticalScrollbar(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.VerticalScrollbar = (UnityEngine.UI.Scrollbar)translator.GetObject(L, 2, typeof(UnityEngine.UI.Scrollbar)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_HorizontalScrollbarVisibility(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + BF.ScrollRectBaseOld.ScrollbarVisibility gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.HorizontalScrollbarVisibility = 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_VerticalScrollbarVisibility(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + BF.ScrollRectBaseOld.ScrollbarVisibility gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.VerticalScrollbarVisibility = 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_HorizontalScrollbarSpacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.HorizontalScrollbarSpacing = (float)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_VerticalScrollbarSpacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.VerticalScrollbarSpacing = (float)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_NormalizedPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.NormalizedPosition = 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_HorizontalNormalizedPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.HorizontalNormalizedPosition = (float)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_VerticalNormalizedPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.VerticalNormalizedPosition = (float)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_bfCell(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.bfCell = (BF.BFCell)translator.GetObject(L, 2, typeof(BF.BFCell)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_useBar(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.useBar = 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_rubberScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.rubberScale = (float)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_onValueChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onValueChanged = translator.GetDelegate>(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_luaInstantiateCellAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaInstantiateCellAction = translator.GetDelegate>(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_luaRefreshAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaRefreshAction = translator.GetDelegate>(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_luaSetSelectedAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaSetSelectedAction = translator.GetDelegate>(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_content(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.content = (UnityEngine.RectTransform)translator.GetObject(L, 2, typeof(UnityEngine.RectTransform)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_horizontal(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.horizontal = 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_vertical(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.vertical = 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_movementType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + BF.ScrollRectBaseOld.MovementType gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.movementType = 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_elasticity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.elasticity = (float)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_inertia(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.inertia = 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_decelerationRate(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.decelerationRate = (float)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_scrollSensitivity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.scrollSensitivity = (float)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_viewport(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.viewport = (UnityEngine.RectTransform)translator.GetObject(L, 2, typeof(UnityEngine.RectTransform)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_velocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectBaseOld gen_to_be_invoked = (BF.ScrollRectBaseOld)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.velocity = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_ScrollRectCenterControllerWrap.cs b/Assets/XLua/Gen/BF_ScrollRectCenterControllerWrap.cs new file mode 100644 index 000000000..83477abd4 --- /dev/null +++ b/Assets/XLua/Gen/BF_ScrollRectCenterControllerWrap.cs @@ -0,0 +1,1299 @@ +#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 BFScrollRectCenterControllerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.ScrollRectCenterController); + Utils.BeginObjectRegister(type, L, translator, 0, 24, 16, 16); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddOnInstantiateCellAction", _m_AddOnInstantiateCellAction); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddRefreshAction", _m_AddRefreshAction); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddSetSelectedAction", _m_AddSetSelectedAction); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddOnCenterAction", _m_AddOnCenterAction); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddOnLeaveCenterAction", _m_AddOnLeaveCenterAction); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddOnBeginDragAction", _m_AddOnBeginDragAction); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddOnEndDragAction", _m_AddOnEndDragAction); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InitComponent", _m_InitComponent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnUpdatePositionVer", _m_OnUpdatePositionVer); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnUpdatePositionHor", _m_OnUpdatePositionHor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBeginDrag", _m_OnBeginDrag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnDrag", _m_OnDrag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnEndDrag", _m_OnEndDrag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetUpdateItemCenter", _m_SetUpdateItemCenter); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "MoveLeft", _m_MoveLeft); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "MoveRight", _m_MoveRight); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "MoveTo", _m_MoveTo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTotalCount", _m_SetTotalCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetScaleRatio", _m_SetScaleRatio); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefillCells", _m_RefillCells); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshAll", _m_RefreshAll); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSelectedIndex", _m_GetSelectedIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSelected", _m_SetSelected); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetCenterIndex", _m_ResetCenterIndex); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bfCell", _g_get_bfCell); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "centerTransform", _g_get_centerTransform); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isDrag", _g_get_isDrag); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "targetPosition", _g_get_targetPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lastDragPoint", _g_get_lastDragPoint); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "moveToImmediately", _g_get_moveToImmediately); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "impactScaleRang", _g_get_impactScaleRang); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "CellScrollScaleType", _g_get_CellScrollScaleType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "CellScrollScaleDistance", _g_get_CellScrollScaleDistance); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaRefreshAction", _g_get_luaRefreshAction); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaInstantiateCellAction", _g_get_luaInstantiateCellAction); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaSetSelectedAction", _g_get_luaSetSelectedAction); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaOnCenterAction", _g_get_luaOnCenterAction); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaOnLeaveCenterAction", _g_get_luaOnLeaveCenterAction); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaOnBeginDragAction", _g_get_luaOnBeginDragAction); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "luaOnEndDragAction", _g_get_luaOnEndDragAction); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "bfCell", _s_set_bfCell); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "centerTransform", _s_set_centerTransform); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "isDrag", _s_set_isDrag); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "targetPosition", _s_set_targetPosition); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "lastDragPoint", _s_set_lastDragPoint); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "moveToImmediately", _s_set_moveToImmediately); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "impactScaleRang", _s_set_impactScaleRang); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "CellScrollScaleType", _s_set_CellScrollScaleType); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "CellScrollScaleDistance", _s_set_CellScrollScaleDistance); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaRefreshAction", _s_set_luaRefreshAction); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaInstantiateCellAction", _s_set_luaInstantiateCellAction); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaSetSelectedAction", _s_set_luaSetSelectedAction); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaOnCenterAction", _s_set_luaOnCenterAction); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaOnLeaveCenterAction", _s_set_luaOnLeaveCenterAction); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaOnBeginDragAction", _s_set_luaOnBeginDragAction); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "luaOnEndDragAction", _s_set_luaOnEndDragAction); + + + 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.ScrollRectCenterController(); + 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.ScrollRectCenterController constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddOnInstantiateCellAction(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.AddOnInstantiateCellAction( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddRefreshAction(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.AddRefreshAction( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddSetSelectedAction(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.AddSetSelectedAction( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddOnCenterAction(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.AddOnCenterAction( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddOnLeaveCenterAction(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.AddOnLeaveCenterAction( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddOnBeginDragAction(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate(L, 2); + + gen_to_be_invoked.AddOnBeginDragAction( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddOnEndDragAction(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate(L, 2); + + gen_to_be_invoked.AddOnEndDragAction( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_InitComponent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.InitComponent( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnUpdatePositionVer(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.OnUpdatePositionVer( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnUpdatePositionHor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.OnUpdatePositionHor( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnBeginDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnBeginDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnEndDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnEndDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetUpdateItemCenter(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + bool _immediately = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.SetUpdateItemCenter( _index, _immediately ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetUpdateItemCenter( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.ScrollRectCenterController.SetUpdateItemCenter!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_MoveLeft(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.MoveLeft( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_MoveRight(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.MoveRight( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_MoveTo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + bool _immediately = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.MoveTo( _index, _immediately ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.MoveTo( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.ScrollRectCenterController.MoveTo!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTotalCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + + + + { + int _totalCount = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetTotalCount( _totalCount ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetScaleRatio(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + + + + { + float _ratio = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.SetScaleRatio( _ratio ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RefillCells(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + + + + { + int _centerIndex = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.RefillCells( _centerIndex ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RefreshAll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RefreshAll( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetSelectedIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetSelectedIndex( ); + 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_SetSelected(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetSelected( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetCenterIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ResetCenterIndex( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bfCell(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.bfCell); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_centerTransform(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.centerTransform); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isDrag(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isDrag); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_targetPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.targetPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lastDragPoint(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.lastDragPoint); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_moveToImmediately(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.moveToImmediately); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_impactScaleRang(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.impactScaleRang); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_CellScrollScaleType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.CellScrollScaleType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_CellScrollScaleDistance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.CellScrollScaleDistance); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaRefreshAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaRefreshAction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaInstantiateCellAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaInstantiateCellAction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaSetSelectedAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaSetSelectedAction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaOnCenterAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaOnCenterAction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaOnLeaveCenterAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaOnLeaveCenterAction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaOnBeginDragAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaOnBeginDragAction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_luaOnEndDragAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.luaOnEndDragAction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_bfCell(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.bfCell = (BF.BFCell)translator.GetObject(L, 2, typeof(BF.BFCell)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_centerTransform(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.centerTransform = (UnityEngine.RectTransform)translator.GetObject(L, 2, typeof(UnityEngine.RectTransform)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_isDrag(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.isDrag = 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_targetPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.targetPosition = (float)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_lastDragPoint(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.lastDragPoint = (float)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_moveToImmediately(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.moveToImmediately = 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_impactScaleRang(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.impactScaleRang = (float)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_CellScrollScaleType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.CellScrollScaleType = 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_CellScrollScaleDistance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.CellScrollScaleDistance = (float)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_luaRefreshAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaRefreshAction = translator.GetDelegate>(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_luaInstantiateCellAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaInstantiateCellAction = translator.GetDelegate>(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_luaSetSelectedAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaSetSelectedAction = translator.GetDelegate>(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_luaOnCenterAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaOnCenterAction = translator.GetDelegate>(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_luaOnLeaveCenterAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaOnLeaveCenterAction = translator.GetDelegate>(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_luaOnBeginDragAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaOnBeginDragAction = translator.GetDelegate(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_luaOnEndDragAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenterController gen_to_be_invoked = (BF.ScrollRectCenterController)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.luaOnEndDragAction = translator.GetDelegate(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_ScrollRectCenterWrap.cs b/Assets/XLua/Gen/BF_ScrollRectCenterWrap.cs new file mode 100644 index 000000000..501b59d67 --- /dev/null +++ b/Assets/XLua/Gen/BF_ScrollRectCenterWrap.cs @@ -0,0 +1,99 @@ +#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 BFScrollRectCenterWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.ScrollRectCenter); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 1, 0); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "scrollRectCenterController", _g_get_scrollRectCenterController); + + + + 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.ScrollRectCenter(); + 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.ScrollRectCenter constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_scrollRectCenterController(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ScrollRectCenter gen_to_be_invoked = (BF.ScrollRectCenter)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.scrollRectCenterController); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_ShowDebugTextWrap.cs b/Assets/XLua/Gen/BF_ShowDebugTextWrap.cs new file mode 100644 index 000000000..922d9f82d --- /dev/null +++ b/Assets/XLua/Gen/BF_ShowDebugTextWrap.cs @@ -0,0 +1,141 @@ +#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 BFShowDebugTextWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.ShowDebugText); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddCallback", _m_AddCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveCallback", _m_RemoveCallback); + + + + + + 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.ShowDebugText(); + 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.ShowDebugText constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ShowDebugText gen_to_be_invoked = (BF.ShowDebugText)translator.FastGetCSObj(L, 1); + + + + { + System.Func _func = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.AddCallback( _func ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.ShowDebugText gen_to_be_invoked = (BF.ShowDebugText)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RemoveCallback( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_ShowFPSWrap.cs b/Assets/XLua/Gen/BF_ShowFPSWrap.cs new file mode 100644 index 000000000..30908adbf --- /dev/null +++ b/Assets/XLua/Gen/BF_ShowFPSWrap.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 BFShowFPSWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.ShowFPS); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 1, 1); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "f_UpdateInterval", _g_get_f_UpdateInterval); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "f_UpdateInterval", _s_set_f_UpdateInterval); + + + 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.ShowFPS(); + 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.ShowFPS constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_f_UpdateInterval(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ShowFPS gen_to_be_invoked = (BF.ShowFPS)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.f_UpdateInterval); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_f_UpdateInterval(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.ShowFPS gen_to_be_invoked = (BF.ShowFPS)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.f_UpdateInterval = (float)LuaAPI.lua_tonumber(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_SimpleAtlasWrap.cs b/Assets/XLua/Gen/BF_SimpleAtlasWrap.cs new file mode 100644 index 000000000..4ebf21c38 --- /dev/null +++ b/Assets/XLua/Gen/BF_SimpleAtlasWrap.cs @@ -0,0 +1,317 @@ +#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 BFSimpleAtlasWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.SimpleAtlas); + Utils.BeginObjectRegister(type, L, translator, 0, 8, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddSprite", _m_AddSprite); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveSprite", _m_RemoveSprite); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveNullSprite", _m_RemoveNullSprite); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Contains", _m_Contains); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetCount", _m_GetCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSprite", _m_GetSprite); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSpriteList", _m_GetSpriteList); + + + + + + 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.SimpleAtlas(); + 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.SimpleAtlas constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddSprite(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SimpleAtlas gen_to_be_invoked = (BF.SimpleAtlas)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Sprite _sprite = (UnityEngine.Sprite)translator.GetObject(L, 2, typeof(UnityEngine.Sprite)); + + var gen_ret = gen_to_be_invoked.AddSprite( _sprite ); + 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_RemoveSprite(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SimpleAtlas gen_to_be_invoked = (BF.SimpleAtlas)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Sprite _sprite = (UnityEngine.Sprite)translator.GetObject(L, 2, typeof(UnityEngine.Sprite)); + + gen_to_be_invoked.RemoveSprite( _sprite ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveNullSprite(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SimpleAtlas gen_to_be_invoked = (BF.SimpleAtlas)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RemoveNullSprite( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Contains(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SimpleAtlas gen_to_be_invoked = (BF.SimpleAtlas)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Sprite _sprite = (UnityEngine.Sprite)translator.GetObject(L, 2, typeof(UnityEngine.Sprite)); + + var gen_ret = gen_to_be_invoked.Contains( _sprite ); + 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_Clear(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SimpleAtlas gen_to_be_invoked = (BF.SimpleAtlas)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Clear( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SimpleAtlas gen_to_be_invoked = (BF.SimpleAtlas)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetCount( ); + 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_GetSprite(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SimpleAtlas gen_to_be_invoked = (BF.SimpleAtlas)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetSprite( _index ); + 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_GetSpriteList(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SimpleAtlas gen_to_be_invoked = (BF.SimpleAtlas)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetSpriteList( ); + 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/BF_SkillSectorMeshWrap.cs b/Assets/XLua/Gen/BF_SkillSectorMeshWrap.cs new file mode 100644 index 000000000..f260f41b9 --- /dev/null +++ b/Assets/XLua/Gen/BF_SkillSectorMeshWrap.cs @@ -0,0 +1,236 @@ +#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 BFSkillSectorMeshWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.SkillSectorMesh); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 4, 4); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshMesh", _m_RefreshMesh); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Radius", _g_get_Radius); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "InnerRadius", _g_get_InnerRadius); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AngleDegree", _g_get_AngleDegree); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Segments", _g_get_Segments); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Radius", _s_set_Radius); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "InnerRadius", _s_set_InnerRadius); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "AngleDegree", _s_set_AngleDegree); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Segments", _s_set_Segments); + + + 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.SkillSectorMesh(); + 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.SkillSectorMesh constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RefreshMesh(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SkillSectorMesh gen_to_be_invoked = (BF.SkillSectorMesh)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RefreshMesh( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Radius(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SkillSectorMesh gen_to_be_invoked = (BF.SkillSectorMesh)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.Radius); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_InnerRadius(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SkillSectorMesh gen_to_be_invoked = (BF.SkillSectorMesh)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.InnerRadius); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AngleDegree(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SkillSectorMesh gen_to_be_invoked = (BF.SkillSectorMesh)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.AngleDegree); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Segments(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SkillSectorMesh gen_to_be_invoked = (BF.SkillSectorMesh)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Segments); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Radius(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SkillSectorMesh gen_to_be_invoked = (BF.SkillSectorMesh)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Radius = (float)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_InnerRadius(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SkillSectorMesh gen_to_be_invoked = (BF.SkillSectorMesh)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.InnerRadius = (float)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_AngleDegree(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SkillSectorMesh gen_to_be_invoked = (BF.SkillSectorMesh)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.AngleDegree = (float)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_Segments(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SkillSectorMesh gen_to_be_invoked = (BF.SkillSectorMesh)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Segments = 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_SocketChannelHelperWrap.cs b/Assets/XLua/Gen/BF_SocketChannelHelperWrap.cs new file mode 100644 index 000000000..84d8bdf2e --- /dev/null +++ b/Assets/XLua/Gen/BF_SocketChannelHelperWrap.cs @@ -0,0 +1,297 @@ +#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 BFSocketChannelHelperWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.SocketChannelHelper); + Utils.BeginObjectRegister(type, L, translator, 0, 5, 2, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRc4Encrypt", _m_SetRc4Encrypt); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Shutdown", _m_Shutdown); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnPack", _m_UnPack); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Serialize", _m_Serialize); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DeserializeHeader", _m_DeserializeHeader); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "HeaderLength", _g_get_HeaderLength); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "InfoLength", _g_get_InfoLength); + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "DeCompressBuffer", _m_DeCompressBuffer_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) == 2 && LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isLittleEndian = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = new BF.SocketChannelHelper(_isLittleEndian); + 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.SocketChannelHelper constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRc4Encrypt(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannelHelper gen_to_be_invoked = (BF.SocketChannelHelper)translator.FastGetCSObj(L, 1); + + + + { + BF.Rc4Encrypt _Rc4Encrypt = (BF.Rc4Encrypt)translator.GetObject(L, 2, typeof(BF.Rc4Encrypt)); + + gen_to_be_invoked.SetRc4Encrypt( _Rc4Encrypt ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Shutdown(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannelHelper gen_to_be_invoked = (BF.SocketChannelHelper)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Shutdown( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UnPack(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannelHelper gen_to_be_invoked = (BF.SocketChannelHelper)translator.FastGetCSObj(L, 1); + + + + { + byte[] _body = LuaAPI.lua_tobytes(L, 2); + uint _group; + int _cmd; + + var gen_ret = gen_to_be_invoked.UnPack( ref _body, out _group, out _cmd ); + LuaAPI.lua_pushboolean(L, gen_ret); + LuaAPI.lua_pushstring(L, _body); + + LuaAPI.xlua_pushuint(L, _group); + + LuaAPI.xlua_pushinteger(L, _cmd); + + + + + return 4; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DeCompressBuffer_xlua_st_(RealStatePtr L) + { + try { + + + + + { + byte[] _byteArray = LuaAPI.lua_tobytes(L, 1); + + var gen_ret = BF.SocketChannelHelper.DeCompressBuffer( _byteArray ); + 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 _m_Serialize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannelHelper gen_to_be_invoked = (BF.SocketChannelHelper)translator.FastGetCSObj(L, 1); + + + + { + BF.SocketChannel.NetPack _pack = (BF.SocketChannel.NetPack)translator.GetObject(L, 2, typeof(BF.SocketChannel.NetPack)); + System.IO.MemoryStream _destination = (System.IO.MemoryStream)translator.GetObject(L, 3, typeof(System.IO.MemoryStream)); + + var gen_ret = gen_to_be_invoked.Serialize( _pack, _destination ); + 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_DeserializeHeader(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannelHelper gen_to_be_invoked = (BF.SocketChannelHelper)translator.FastGetCSObj(L, 1); + + + + { + BF.ICircularBuffer _receiveBuffer = (BF.ICircularBuffer)translator.GetObject(L, 2, typeof(BF.ICircularBuffer)); + + var gen_ret = gen_to_be_invoked.DeserializeHeader( _receiveBuffer ); + 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 _g_get_HeaderLength(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SocketChannelHelper gen_to_be_invoked = (BF.SocketChannelHelper)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.HeaderLength); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_InfoLength(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SocketChannelHelper gen_to_be_invoked = (BF.SocketChannelHelper)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.InfoLength); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_SocketChannelManagerWrap.cs b/Assets/XLua/Gen/BF_SocketChannelManagerWrap.cs new file mode 100644 index 000000000..ed0e13e09 --- /dev/null +++ b/Assets/XLua/Gen/BF_SocketChannelManagerWrap.cs @@ -0,0 +1,353 @@ +#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 BFSocketChannelManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.SocketChannelManager); + Utils.BeginObjectRegister(type, L, translator, 0, 8, 1, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasSocketChannel", _m_HasSocketChannel); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSocketChannel", _m_GetSocketChannel); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAllSocketChannels", _m_GetAllSocketChannels); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryGetSocketChannel", _m_TryGetSocketChannel); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CreateSocketChannel", _m_CreateSocketChannel); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DestroySocketChannel", _m_DestroySocketChannel); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Shutdown", _m_Shutdown); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Update", _m_Update); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "SocketChannelCount", _g_get_SocketChannelCount); + + + + 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.SocketChannelManager(); + 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.SocketChannelManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasSocketChannel(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannelManager gen_to_be_invoked = (BF.SocketChannelManager)translator.FastGetCSObj(L, 1); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.HasSocketChannel( _name ); + 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_GetSocketChannel(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannelManager gen_to_be_invoked = (BF.SocketChannelManager)translator.FastGetCSObj(L, 1); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetSocketChannel( _name ); + 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_GetAllSocketChannels(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannelManager gen_to_be_invoked = (BF.SocketChannelManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetAllSocketChannels( ); + 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_TryGetSocketChannel(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannelManager gen_to_be_invoked = (BF.SocketChannelManager)translator.FastGetCSObj(L, 1); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.TryGetSocketChannel( _name ); + 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_CreateSocketChannel(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannelManager gen_to_be_invoked = (BF.SocketChannelManager)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + BF.ISocketChannelHelper _socketChannelHelper = (BF.ISocketChannelHelper)translator.GetObject(L, 3, typeof(BF.ISocketChannelHelper)); + + var gen_ret = gen_to_be_invoked.CreateSocketChannel( _name, _socketChannelHelper ); + translator.PushAny(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)&& translator.Assignable>(L, 4)) + { + string _name = LuaAPI.lua_tostring(L, 2); + BF.ISocketChannelHelper _socketChannelHelper = (BF.ISocketChannelHelper)translator.GetObject(L, 3, typeof(BF.ISocketChannelHelper)); + System.Action _callback = translator.GetDelegate>(L, 4); + + gen_to_be_invoked.CreateSocketChannel( _name, _socketChannelHelper, _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.SocketChannelManager.CreateSocketChannel!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DestroySocketChannel(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannelManager gen_to_be_invoked = (BF.SocketChannelManager)translator.FastGetCSObj(L, 1); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.DestroySocketChannel( _name ); + 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_Shutdown(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannelManager gen_to_be_invoked = (BF.SocketChannelManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Shutdown( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Update(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannelManager gen_to_be_invoked = (BF.SocketChannelManager)translator.FastGetCSObj(L, 1); + + + + { + float _elapseSeconds = (float)LuaAPI.lua_tonumber(L, 2); + float _realElapseSeconds = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.Update( _elapseSeconds, _realElapseSeconds ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_SocketChannelCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SocketChannelManager gen_to_be_invoked = (BF.SocketChannelManager)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.SocketChannelCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_SocketChannelWrap.cs b/Assets/XLua/Gen/BF_SocketChannelWrap.cs new file mode 100644 index 000000000..1296d8dc9 --- /dev/null +++ b/Assets/XLua/Gen/BF_SocketChannelWrap.cs @@ -0,0 +1,870 @@ +#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 BFSocketChannelWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.SocketChannel); + Utils.BeginObjectRegister(type, L, translator, 0, 19, 9, 2); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ConnectWithIp", _m_ConnectWithIp); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ConnectWithDomainName", _m_ConnectWithDomainName); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Connect", _m_Connect); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Send", _m_Send); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SendRaw", _m_SendRaw); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Update", _m_Update); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ProcessSend", _m_ProcessSend); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ProcessReceive", _m_ProcessReceive); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddLuaOnConnectedListener", _m_AddLuaOnConnectedListener); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddLuaOnDisconnectListener", _m_AddLuaOnDisconnectListener); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddLuaOnReceiveListener", _m_AddLuaOnReceiveListener); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearLuaOnReceiveListener", _m_ClearLuaOnReceiveListener); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddLuaOnErrorListener", _m_AddLuaOnErrorListener); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Close", _m_Close); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Shutdown", _m_Shutdown); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnConnected", _e_OnConnected); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnDisconnected", _e_OnDisconnected); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnReceive", _e_OnReceive); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnError", _e_OnError); + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Name", _g_get_Name); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ProcessReceiveCountPerFrame", _g_get_ProcessReceiveCountPerFrame); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ConnectIP", _g_get_ConnectIP); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Socket", _g_get_Socket); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsConnected", _g_get_IsConnected); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "NetType", _g_get_NetType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "HeartBeatInterval", _g_get_HeartBeatInterval); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "HeartBeatWaitSeconds", _g_get_HeartBeatWaitSeconds); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "HeartBeatMissCount", _g_get_HeartBeatMissCount); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ProcessReceiveCountPerFrame", _s_set_ProcessReceiveCountPerFrame); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "HeartBeatInterval", _s_set_HeartBeatInterval); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetRandomString", _m_GetRandomString_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) == 3 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING) && translator.Assignable(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + BF.ISocketChannelHelper _channelHelper = (BF.ISocketChannelHelper)translator.GetObject(L, 3, typeof(BF.ISocketChannelHelper)); + + var gen_ret = new BF.SocketChannel(_name, _channelHelper); + 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.SocketChannel constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ConnectWithIp(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)translator.FastGetCSObj(L, 1); + + + + { + string _ip = LuaAPI.lua_tostring(L, 2); + int _port = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.ConnectWithIp( _ip, _port ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ConnectWithDomainName(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)translator.FastGetCSObj(L, 1); + + + + { + string _domainName = LuaAPI.lua_tostring(L, 2); + int _port = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.ConnectWithDomainName( _domainName, _port ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Connect(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)translator.FastGetCSObj(L, 1); + + + + { + System.Net.IPAddress _ipAddress = (System.Net.IPAddress)translator.GetObject(L, 2, typeof(System.Net.IPAddress)); + int _port = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.Connect( _ipAddress, _port ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Send(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.Send( ); + + + + return 0; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + byte[] _bytes = LuaAPI.lua_tobytes(L, 2); + uint _group = LuaAPI.xlua_touint(L, 3); + byte _cmd = (byte)LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.Send( _bytes, _group, _cmd ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.SocketChannel.Send!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SendRaw(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)translator.FastGetCSObj(L, 1); + + + + { + byte[] _bytes = LuaAPI.lua_tobytes(L, 2); + byte _group = (byte)LuaAPI.xlua_tointeger(L, 3); + byte _cmd = (byte)LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.SendRaw( _bytes, _group, _cmd ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Update(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)translator.FastGetCSObj(L, 1); + + + + { + float _elapseSeconds = (float)LuaAPI.lua_tonumber(L, 2); + float _realElapseSeconds = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.Update( _elapseSeconds, _realElapseSeconds ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ProcessSend(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ProcessSend( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ProcessReceive(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ProcessReceive( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddLuaOnConnectedListener(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)translator.FastGetCSObj(L, 1); + + + + { + System.Action _luaFunc = translator.GetDelegate(L, 2); + + gen_to_be_invoked.AddLuaOnConnectedListener( _luaFunc ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddLuaOnDisconnectListener(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)translator.FastGetCSObj(L, 1); + + + + { + System.Action _luaFunc = translator.GetDelegate(L, 2); + + gen_to_be_invoked.AddLuaOnDisconnectListener( _luaFunc ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddLuaOnReceiveListener(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)translator.FastGetCSObj(L, 1); + + + + { + System.Action _luaFunc = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.AddLuaOnReceiveListener( _luaFunc ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearLuaOnReceiveListener(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearLuaOnReceiveListener( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddLuaOnErrorListener(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)translator.FastGetCSObj(L, 1); + + + + { + System.Action _luaFunc = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.AddLuaOnErrorListener( _luaFunc ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Close(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Close( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Shutdown(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Shutdown( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetRandomString_xlua_st_(RealStatePtr L) + { + try { + + + + + { + int _len = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = BF.SocketChannel.GetRandomString( _len ); + 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_Name(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)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_ProcessReceiveCountPerFrame(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.ProcessReceiveCountPerFrame); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ConnectIP(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.ConnectIP); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Socket(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Socket); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsConnected(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsConnected); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_NetType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.NetType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_HeartBeatInterval(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.HeartBeatInterval); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_HeartBeatWaitSeconds(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.HeartBeatWaitSeconds); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_HeartBeatMissCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.HeartBeatMissCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_ProcessReceiveCountPerFrame(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ProcessReceiveCountPerFrame = 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_HeartBeatInterval(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.HeartBeatInterval = (float)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 _e_OnConnected(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnConnected += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnConnected -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to BF.SocketChannel.OnConnected!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnDisconnected(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnDisconnected += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnDisconnected -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to BF.SocketChannel.OnDisconnected!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnReceive(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnReceive += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnReceive -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to BF.SocketChannel.OnReceive!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnError(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + BF.SocketChannel gen_to_be_invoked = (BF.SocketChannel)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnError += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnError -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to BF.SocketChannel.OnError!"); + return 0; + } + + + + } +} diff --git a/Assets/XLua/Gen/BF_SocketChannel_NetPackWrap.cs b/Assets/XLua/Gen/BF_SocketChannel_NetPackWrap.cs new file mode 100644 index 000000000..014308e19 --- /dev/null +++ b/Assets/XLua/Gen/BF_SocketChannel_NetPackWrap.cs @@ -0,0 +1,361 @@ +#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 BFSocketChannelNetPackWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.SocketChannel.NetPack); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 5, 5); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Reset", _m_Reset); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "group", _g_get_group); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "cmd", _g_get_cmd); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "seq", _g_get_seq); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "data", _g_get_data); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "packDataLength", _g_get_packDataLength); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "group", _s_set_group); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "cmd", _s_set_cmd); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "seq", _s_set_seq); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "data", _s_set_data); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "packDataLength", _s_set_packDataLength); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 3, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CreateNetPack", _m_CreateNetPack_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RecycleNetPack", _m_RecycleNetPack_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) == 5 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4) && (LuaAPI.lua_isnil(L, 5) || LuaAPI.lua_type(L, 5) == LuaTypes.LUA_TSTRING)) + { + int _s = LuaAPI.xlua_tointeger(L, 2); + uint _g = LuaAPI.xlua_touint(L, 3); + byte _c = (byte)LuaAPI.xlua_tointeger(L, 4); + byte[] _d = LuaAPI.lua_tobytes(L, 5); + + var gen_ret = new BF.SocketChannel.NetPack(_s, _g, _c, _d); + 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.SocketChannel.NetPack constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannel.NetPack gen_to_be_invoked = (BF.SocketChannel.NetPack)translator.FastGetCSObj(L, 1); + + + + { + int _s = LuaAPI.xlua_tointeger(L, 2); + uint _g = LuaAPI.xlua_touint(L, 3); + byte _c = (byte)LuaAPI.xlua_tointeger(L, 4); + byte[] _d = LuaAPI.lua_tobytes(L, 5); + + gen_to_be_invoked.Init( _s, _g, _c, _d ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Reset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketChannel.NetPack gen_to_be_invoked = (BF.SocketChannel.NetPack)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Reset( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CreateNetPack_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + int _seq = LuaAPI.xlua_tointeger(L, 1); + uint _group = LuaAPI.xlua_touint(L, 2); + byte _cmd = (byte)LuaAPI.xlua_tointeger(L, 3); + byte[] _data = LuaAPI.lua_tobytes(L, 4); + + var gen_ret = BF.SocketChannel.NetPack.CreateNetPack( _seq, _group, _cmd, _data ); + 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_RecycleNetPack_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + BF.SocketChannel.NetPack _pack = (BF.SocketChannel.NetPack)translator.GetObject(L, 1, typeof(BF.SocketChannel.NetPack)); + + BF.SocketChannel.NetPack.RecycleNetPack( _pack ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_group(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SocketChannel.NetPack gen_to_be_invoked = (BF.SocketChannel.NetPack)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushuint(L, gen_to_be_invoked.group); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cmd(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SocketChannel.NetPack gen_to_be_invoked = (BF.SocketChannel.NetPack)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.cmd); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_seq(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SocketChannel.NetPack gen_to_be_invoked = (BF.SocketChannel.NetPack)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.seq); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_data(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SocketChannel.NetPack gen_to_be_invoked = (BF.SocketChannel.NetPack)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.data); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_packDataLength(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SocketChannel.NetPack gen_to_be_invoked = (BF.SocketChannel.NetPack)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.packDataLength); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_group(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SocketChannel.NetPack gen_to_be_invoked = (BF.SocketChannel.NetPack)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.group = LuaAPI.xlua_touint(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_cmd(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SocketChannel.NetPack gen_to_be_invoked = (BF.SocketChannel.NetPack)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.cmd = (byte)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_seq(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SocketChannel.NetPack gen_to_be_invoked = (BF.SocketChannel.NetPack)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.seq = 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_data(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SocketChannel.NetPack gen_to_be_invoked = (BF.SocketChannel.NetPack)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.data = LuaAPI.lua_tobytes(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_packDataLength(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.SocketChannel.NetPack gen_to_be_invoked = (BF.SocketChannel.NetPack)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.packDataLength = 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_SocketManagerWrap.cs b/Assets/XLua/Gen/BF_SocketManagerWrap.cs new file mode 100644 index 000000000..9c616ab46 --- /dev/null +++ b/Assets/XLua/Gen/BF_SocketManagerWrap.cs @@ -0,0 +1,296 @@ +#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 BFSocketManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.SocketManager); + Utils.BeginObjectRegister(type, L, translator, 0, 7, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Update", _m_Update); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryGetSocketClient", _m_TryGetSocketClient); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CreateSocketClient", _m_CreateSocketClient); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DestroySocketChannel", _m_DestroySocketChannel); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Shutdown", _m_Shutdown); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Destroy", _m_Destroy); + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Create", _m_Create_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "BF.SocketManager does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Create_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = BF.SocketManager.Create( ); + 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_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketManager gen_to_be_invoked = (BF.SocketManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Update(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketManager gen_to_be_invoked = (BF.SocketManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Update( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TryGetSocketClient(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketManager gen_to_be_invoked = (BF.SocketManager)translator.FastGetCSObj(L, 1); + + + + { + string _channelName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.TryGetSocketClient( _channelName ); + 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_CreateSocketClient(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketManager gen_to_be_invoked = (BF.SocketManager)translator.FastGetCSObj(L, 1); + + + + { + string _channelName = LuaAPI.lua_tostring(L, 2); + System.Action _callback = translator.GetDelegate>(L, 3); + + gen_to_be_invoked.CreateSocketClient( _channelName, _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DestroySocketChannel(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketManager gen_to_be_invoked = (BF.SocketManager)translator.FastGetCSObj(L, 1); + + + + { + string _channelName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.DestroySocketChannel( _channelName ); + 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_Shutdown(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketManager gen_to_be_invoked = (BF.SocketManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Shutdown( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Destroy(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SocketManager gen_to_be_invoked = (BF.SocketManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Destroy( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_SoundManagerWrap.cs b/Assets/XLua/Gen/BF_SoundManagerWrap.cs new file mode 100644 index 000000000..bef76a9b3 --- /dev/null +++ b/Assets/XLua/Gen/BF_SoundManagerWrap.cs @@ -0,0 +1,208 @@ +#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 BFSoundManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.SoundManager); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "getMusicAudioSource", _m_getMusicAudioSource); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "addEffectAudioSource", _m_addEffectAudioSource); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "clearAudioSource", _m_clearAudioSource); + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Create", _m_Create_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "BF.SoundManager does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Create_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = BF.SoundManager.Create( ); + 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_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SoundManager gen_to_be_invoked = (BF.SoundManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_getMusicAudioSource(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SoundManager gen_to_be_invoked = (BF.SoundManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.getMusicAudioSource( ); + 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_addEffectAudioSource(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SoundManager gen_to_be_invoked = (BF.SoundManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.addEffectAudioSource( ); + 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_clearAudioSource(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.SoundManager gen_to_be_invoked = (BF.SoundManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.clearAudioSource( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_StringConstWrap.cs b/Assets/XLua/Gen/BF_StringConstWrap.cs new file mode 100644 index 000000000..de9370dd8 --- /dev/null +++ b/Assets/XLua/Gen/BF_StringConstWrap.cs @@ -0,0 +1,121 @@ +#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 BFStringConstWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.StringConst); + 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, 1, 1); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetScrollRectCellName", _m_GetScrollRectCellName_xlua_st_); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CACHE_ROOT_NAME", BF.StringConst.CACHE_ROOT_NAME); + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "SCROLL_RECT_CELL_NAME", _g_get_SCROLL_RECT_CELL_NAME); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "SCROLL_RECT_CELL_NAME", _s_set_SCROLL_RECT_CELL_NAME); + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "BF.StringConst does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetScrollRectCellName_xlua_st_(RealStatePtr L) + { + try { + + + + + { + int _index = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = BF.StringConst.GetScrollRectCellName( _index ); + 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_SCROLL_RECT_CELL_NAME(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, BF.StringConst.SCROLL_RECT_CELL_NAME); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_SCROLL_RECT_CELL_NAME(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + BF.StringConst.SCROLL_RECT_CELL_NAME = (System.Collections.Generic.List)translator.GetObject(L, 1, 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/BF_TaskManagerWrap.cs b/Assets/XLua/Gen/BF_TaskManagerWrap.cs new file mode 100644 index 000000000..21dbaac0c --- /dev/null +++ b/Assets/XLua/Gen/BF_TaskManagerWrap.cs @@ -0,0 +1,312 @@ +#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 BFTaskManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.TaskManager); + Utils.BeginObjectRegister(type, L, translator, 0, 7, 1, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMono", _m_SetMono); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddTask", _m_AddTask); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "StopTask", _m_StopTask); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveTask", _m_RemoveTask); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "EasyTimer", _m_EasyTimer); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Update", _m_Update); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "TaskCount", _g_get_TaskCount); + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Create", _m_Create_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "BF.TaskManager does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Create_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = BF.TaskManager.Create( ); + 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_SetMono(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TaskManager gen_to_be_invoked = (BF.TaskManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.MonoBehaviour _mono = (UnityEngine.MonoBehaviour)translator.GetObject(L, 2, typeof(UnityEngine.MonoBehaviour)); + + gen_to_be_invoked.SetMono( _mono ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TaskManager gen_to_be_invoked = (BF.TaskManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddTask(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TaskManager gen_to_be_invoked = (BF.TaskManager)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.IEnumerator _c = (System.Collections.IEnumerator)translator.GetObject(L, 2, typeof(System.Collections.IEnumerator)); + + var gen_ret = gen_to_be_invoked.AddTask( _c ); + 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_StopTask(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TaskManager gen_to_be_invoked = (BF.TaskManager)translator.FastGetCSObj(L, 1); + + + + { + int _taskID = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.StopTask( _taskID ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveTask(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TaskManager gen_to_be_invoked = (BF.TaskManager)translator.FastGetCSObj(L, 1); + + + + { + int _taskID = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.RemoveTask( _taskID ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_EasyTimer(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TaskManager gen_to_be_invoked = (BF.TaskManager)translator.FastGetCSObj(L, 1); + + + + { + float _time = (float)LuaAPI.lua_tonumber(L, 2); + System.Action _action = translator.GetDelegate(L, 3); + + gen_to_be_invoked.EasyTimer( _time, _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Update(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TaskManager gen_to_be_invoked = (BF.TaskManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Update( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_TaskCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.TaskManager gen_to_be_invoked = (BF.TaskManager)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.TaskCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_TaskWrap.cs b/Assets/XLua/Gen/BF_TaskWrap.cs new file mode 100644 index 000000000..577225cc5 --- /dev/null +++ b/Assets/XLua/Gen/BF_TaskWrap.cs @@ -0,0 +1,229 @@ +#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 BFTaskWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.Task); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 2, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Stop", _m_Stop); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Pause", _m_Pause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Unpause", _m_Unpause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CallWrapper", _m_CallWrapper); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Running", _g_get_Running); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Paused", _g_get_Paused); + + + + 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 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && translator.Assignable(L, 3)) + { + int _taskID = LuaAPI.xlua_tointeger(L, 2); + System.Collections.IEnumerator _c = (System.Collections.IEnumerator)translator.GetObject(L, 3, typeof(System.Collections.IEnumerator)); + + var gen_ret = new BF.Task(_taskID, _c); + 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.Task constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Stop(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.Task gen_to_be_invoked = (BF.Task)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Stop( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Pause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.Task gen_to_be_invoked = (BF.Task)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Pause( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Unpause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.Task gen_to_be_invoked = (BF.Task)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Unpause( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CallWrapper(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.Task gen_to_be_invoked = (BF.Task)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.CallWrapper( ); + 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 _g_get_Running(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.Task gen_to_be_invoked = (BF.Task)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.Running); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Paused(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.Task gen_to_be_invoked = (BF.Task)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.Paused); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_TimeHelperWrap.cs b/Assets/XLua/Gen/BF_TimeHelperWrap.cs new file mode 100644 index 000000000..23232b8b5 --- /dev/null +++ b/Assets/XLua/Gen/BF_TimeHelperWrap.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 BFTimeHelperWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.TimeHelper); + 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, "GetDayBeginTimestamp", _m_GetDayBeginTimestamp_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "BF.TimeHelper does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetDayBeginTimestamp_xlua_st_(RealStatePtr L) + { + try { + + + + + { + long _timestamp = LuaAPI.lua_toint64(L, 1); + int _timeZoneOffset = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = BF.TimeHelper.GetDayBeginTimestamp( _timestamp, _timeZoneOffset ); + LuaAPI.lua_pushint64(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_TimeLineItemWrap.cs b/Assets/XLua/Gen/BF_TimeLineItemWrap.cs new file mode 100644 index 000000000..913eace47 --- /dev/null +++ b/Assets/XLua/Gen/BF_TimeLineItemWrap.cs @@ -0,0 +1,539 @@ +#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 BFTimeLineItemWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.TimeLineItem); + Utils.BeginObjectRegister(type, L, translator, 0, 13, 2, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FrameMove", _m_FrameMove); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RegisterEvent", _m_RegisterEvent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Play", _m_Play); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Pause", _m_Pause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Resume", _m_Resume); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Stop", _m_Stop); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Reset", _m_Reset); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetAndPlay", _m_ResetAndPlay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetBindingObject", _m_GetBindingObject); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Binding", _m_Binding); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnBinding", _m_UnBinding); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearAllBinding", _m_ClearAllBinding); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Duration", _g_get_Duration); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onComplete", _g_get_onComplete); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onComplete", _s_set_onComplete); + + + 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.TimeLineItem(); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && translator.Assignable(L, 2)) + { + UnityEngine.Playables.PlayableDirector _pd = (UnityEngine.Playables.PlayableDirector)translator.GetObject(L, 2, typeof(UnityEngine.Playables.PlayableDirector)); + + var gen_ret = new BF.TimeLineItem(_pd); + 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.TimeLineItem constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FrameMove(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineItem gen_to_be_invoked = (BF.TimeLineItem)translator.FastGetCSObj(L, 1); + + + + { + double _delta = LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.FrameMove( _delta ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RegisterEvent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineItem gen_to_be_invoked = (BF.TimeLineItem)translator.FastGetCSObj(L, 1); + + + + { + double _time = LuaAPI.lua_tonumber(L, 2); + System.Action _e = translator.GetDelegate(L, 3); + + gen_to_be_invoked.RegisterEvent( _time, _e ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Play(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineItem gen_to_be_invoked = (BF.TimeLineItem)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Play( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Pause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineItem gen_to_be_invoked = (BF.TimeLineItem)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Pause( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Resume(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineItem gen_to_be_invoked = (BF.TimeLineItem)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Resume( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Stop(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineItem gen_to_be_invoked = (BF.TimeLineItem)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Stop( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Reset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineItem gen_to_be_invoked = (BF.TimeLineItem)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.Reset( ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + double _timePoint = LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.Reset( _timePoint ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.TimeLineItem.Reset!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetAndPlay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineItem gen_to_be_invoked = (BF.TimeLineItem)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.ResetAndPlay( ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + double _timePoint = LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.ResetAndPlay( _timePoint ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.TimeLineItem.ResetAndPlay!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetBindingObject(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineItem gen_to_be_invoked = (BF.TimeLineItem)translator.FastGetCSObj(L, 1); + + + + { + string _trackName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetBindingObject( _trackName ); + 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_Binding(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineItem gen_to_be_invoked = (BF.TimeLineItem)translator.FastGetCSObj(L, 1); + + + + { + string _trackName = LuaAPI.lua_tostring(L, 2); + UnityEngine.Object _obj = (UnityEngine.Object)translator.GetObject(L, 3, typeof(UnityEngine.Object)); + + gen_to_be_invoked.Binding( _trackName, _obj ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UnBinding(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineItem gen_to_be_invoked = (BF.TimeLineItem)translator.FastGetCSObj(L, 1); + + + + { + string _trackName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.UnBinding( _trackName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearAllBinding(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineItem gen_to_be_invoked = (BF.TimeLineItem)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearAllBinding( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Clear(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineItem gen_to_be_invoked = (BF.TimeLineItem)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Clear( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Duration(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.TimeLineItem gen_to_be_invoked = (BF.TimeLineItem)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.Duration); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onComplete(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.TimeLineItem gen_to_be_invoked = (BF.TimeLineItem)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onComplete); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_onComplete(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.TimeLineItem gen_to_be_invoked = (BF.TimeLineItem)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onComplete = translator.GetDelegate(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_TimeLineItem_FrameDataWrap.cs b/Assets/XLua/Gen/BF_TimeLineItem_FrameDataWrap.cs new file mode 100644 index 000000000..14b68c5b5 --- /dev/null +++ b/Assets/XLua/Gen/BF_TimeLineItem_FrameDataWrap.cs @@ -0,0 +1,158 @@ +#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 BFTimeLineItemFrameDataWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.TimeLineItem.FrameData); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 2); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "time", _g_get_time); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "e", _g_get_e); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "time", _s_set_time); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "e", _s_set_e); + + + 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 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && translator.Assignable(L, 3)) + { + double _t = LuaAPI.lua_tonumber(L, 2); + System.Action _a = translator.GetDelegate(L, 3); + + var gen_ret = new BF.TimeLineItem.FrameData(_t, _a); + translator.Push(L, gen_ret); + + return 1; + } + + if (LuaAPI.lua_gettop(L) == 1) + { + translator.Push(L, default(BF.TimeLineItem.FrameData)); + 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.TimeLineItem.FrameData constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_time(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.TimeLineItem.FrameData gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.time); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_e(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.TimeLineItem.FrameData gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.e); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_time(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.TimeLineItem.FrameData gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.time = LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_e(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.TimeLineItem.FrameData gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.e = translator.GetDelegate(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_TimeLineManagerWrap.cs b/Assets/XLua/Gen/BF_TimeLineManagerWrap.cs new file mode 100644 index 000000000..a09ddbe5f --- /dev/null +++ b/Assets/XLua/Gen/BF_TimeLineManagerWrap.cs @@ -0,0 +1,668 @@ +#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 BFTimeLineManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.TimeLineManager); + Utils.BeginObjectRegister(type, L, translator, 0, 18, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Update", _m_Update); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LateUpdate", _m_LateUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Destroy", _m_Destroy); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Load", _m_Load); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Unload", _m_Unload); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Binding", _m_Binding); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Unbinding", _m_Unbinding); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearBinding", _m_ClearBinding); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Play", _m_Play); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Pause", _m_Pause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Resume", _m_Resume); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Stop", _m_Stop); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Reset", _m_Reset); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetAndPlay", _m_ResetAndPlay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RegisterCompleteCallback", _m_RegisterCompleteCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RegisterCallback", _m_RegisterCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTimelineTime", _m_GetTimelineTime); + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Create", _m_Create_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 BF.TimeLineManager(); + 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.TimeLineManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Create_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = BF.TimeLineManager.Create( ); + 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_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineManager gen_to_be_invoked = (BF.TimeLineManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Update(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineManager gen_to_be_invoked = (BF.TimeLineManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Update( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LateUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineManager gen_to_be_invoked = (BF.TimeLineManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.LateUpdate( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Destroy(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineManager gen_to_be_invoked = (BF.TimeLineManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Destroy( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Load(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineManager gen_to_be_invoked = (BF.TimeLineManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.GameObject _tlObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + var gen_ret = gen_to_be_invoked.Load( _tlObject ); + 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_Unload(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineManager gen_to_be_invoked = (BF.TimeLineManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.GameObject _tlObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + var gen_ret = gen_to_be_invoked.Unload( _tlObject ); + 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_Binding(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineManager gen_to_be_invoked = (BF.TimeLineManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.GameObject _tlObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + string _trackName = LuaAPI.lua_tostring(L, 3); + UnityEngine.Object _obj = (UnityEngine.Object)translator.GetObject(L, 4, typeof(UnityEngine.Object)); + + gen_to_be_invoked.Binding( _tlObject, _trackName, _obj ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Unbinding(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineManager gen_to_be_invoked = (BF.TimeLineManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.GameObject _tlObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + string _trackName = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.Unbinding( _tlObject, _trackName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearBinding(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineManager gen_to_be_invoked = (BF.TimeLineManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.GameObject _tlObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + gen_to_be_invoked.ClearBinding( _tlObject ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Play(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineManager gen_to_be_invoked = (BF.TimeLineManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.GameObject _tlObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + gen_to_be_invoked.Play( _tlObject ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Pause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineManager gen_to_be_invoked = (BF.TimeLineManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.GameObject _tlObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + gen_to_be_invoked.Pause( _tlObject ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Resume(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineManager gen_to_be_invoked = (BF.TimeLineManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.GameObject _tlObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + gen_to_be_invoked.Resume( _tlObject ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Stop(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineManager gen_to_be_invoked = (BF.TimeLineManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.GameObject _tlObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + gen_to_be_invoked.Stop( _tlObject ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Reset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineManager gen_to_be_invoked = (BF.TimeLineManager)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.GameObject _tlObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + gen_to_be_invoked.Reset( _tlObject ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.GameObject _tlObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + double _timePoint = LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.Reset( _tlObject, _timePoint ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.TimeLineManager.Reset!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetAndPlay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineManager gen_to_be_invoked = (BF.TimeLineManager)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.GameObject _tlObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + gen_to_be_invoked.ResetAndPlay( _tlObject ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.GameObject _tlObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + double _timePoint = LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.ResetAndPlay( _tlObject, _timePoint ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.TimeLineManager.ResetAndPlay!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RegisterCompleteCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineManager gen_to_be_invoked = (BF.TimeLineManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.GameObject _tlObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + System.Action _action = translator.GetDelegate(L, 3); + + gen_to_be_invoked.RegisterCompleteCallback( _tlObject, _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RegisterCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineManager gen_to_be_invoked = (BF.TimeLineManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.GameObject _tlObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + double _time = LuaAPI.lua_tonumber(L, 3); + System.Action _action = translator.GetDelegate(L, 4); + + gen_to_be_invoked.RegisterCallback( _tlObject, _time, _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetTimelineTime(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimeLineManager gen_to_be_invoked = (BF.TimeLineManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.GameObject _tlObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + var gen_ret = gen_to_be_invoked.GetTimelineTime( _tlObject ); + LuaAPI.lua_pushnumber(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_TimelineEventItemWrap.cs b/Assets/XLua/Gen/BF_TimelineEventItemWrap.cs new file mode 100644 index 000000000..2c80a0818 --- /dev/null +++ b/Assets/XLua/Gen/BF_TimelineEventItemWrap.cs @@ -0,0 +1,181 @@ +#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 BFTimelineEventItemWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.TimelineEventItem); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 3, 3); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "eventName", _g_get_eventName); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "eventHash", _g_get_eventHash); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "eventTime", _g_get_eventTime); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "eventName", _s_set_eventName); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "eventHash", _s_set_eventHash); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "eventTime", _s_set_eventTime); + + + 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) + { + translator.Push(L, default(BF.TimelineEventItem)); + 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.TimelineEventItem constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_eventName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.TimelineEventItem gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.eventName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_eventHash(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.TimelineEventItem gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushuint(L, gen_to_be_invoked.eventHash); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_eventTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.TimelineEventItem gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.eventTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_eventName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.TimelineEventItem gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.eventName = LuaAPI.lua_tostring(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_eventHash(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.TimelineEventItem gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.eventHash = LuaAPI.xlua_touint(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_eventTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.TimelineEventItem gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.eventTime = LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_TimelineHelperWrap.cs b/Assets/XLua/Gen/BF_TimelineHelperWrap.cs new file mode 100644 index 000000000..c615af370 --- /dev/null +++ b/Assets/XLua/Gen/BF_TimelineHelperWrap.cs @@ -0,0 +1,444 @@ +#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 BFTimelineHelperWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.TimelineHelper); + Utils.BeginObjectRegister(type, L, translator, 0, 9, 3, 3); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetGameObjectByName", _m_GetGameObjectByName); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetListCount", _m_GetListCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetObjectTypeByIndex", _m_GetObjectTypeByIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashNameByIndex", _m_GetHashNameByIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetGameObjectByIndex", _m_GetGameObjectByIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetRootPrefabIndex", _m_GetRootPrefabIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetEventListCount", _m_GetEventListCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetEventHashNameByIndex", _m_GetEventHashNameByIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetEventTimeByIndex", _m_GetEventTimeByIndex); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "prefabList", _g_get_prefabList); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "duration", _g_get_duration); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "timelineEventList", _g_get_timelineEventList); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "prefabList", _s_set_prefabList); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "duration", _s_set_duration); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "timelineEventList", _s_set_timelineEventList); + + + 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.TimelineHelper(); + 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.TimelineHelper constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetGameObjectByName(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimelineHelper gen_to_be_invoked = (BF.TimelineHelper)translator.FastGetCSObj(L, 1); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetGameObjectByName( _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_GetListCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimelineHelper gen_to_be_invoked = (BF.TimelineHelper)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetListCount( ); + 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_GetObjectTypeByIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimelineHelper gen_to_be_invoked = (BF.TimelineHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetObjectTypeByIndex( _index ); + 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_GetHashNameByIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimelineHelper gen_to_be_invoked = (BF.TimelineHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetHashNameByIndex( _index ); + LuaAPI.xlua_pushuint(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_GetGameObjectByIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimelineHelper gen_to_be_invoked = (BF.TimelineHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetGameObjectByIndex( _index ); + 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_GetRootPrefabIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimelineHelper gen_to_be_invoked = (BF.TimelineHelper)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetRootPrefabIndex( ); + 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_GetEventListCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimelineHelper gen_to_be_invoked = (BF.TimelineHelper)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetEventListCount( ); + 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_GetEventHashNameByIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimelineHelper gen_to_be_invoked = (BF.TimelineHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetEventHashNameByIndex( _index ); + LuaAPI.xlua_pushuint(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_GetEventTimeByIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimelineHelper gen_to_be_invoked = (BF.TimelineHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetEventTimeByIndex( _index ); + LuaAPI.lua_pushnumber(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_prefabList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.TimelineHelper gen_to_be_invoked = (BF.TimelineHelper)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.prefabList); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_duration(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.TimelineHelper gen_to_be_invoked = (BF.TimelineHelper)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.duration); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_timelineEventList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.TimelineHelper gen_to_be_invoked = (BF.TimelineHelper)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.timelineEventList); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_prefabList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.TimelineHelper gen_to_be_invoked = (BF.TimelineHelper)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.prefabList = (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; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_duration(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.TimelineHelper gen_to_be_invoked = (BF.TimelineHelper)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.duration = 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_timelineEventList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.TimelineHelper gen_to_be_invoked = (BF.TimelineHelper)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.timelineEventList = (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/BF_TimelineSortingOderHelperWrap.cs b/Assets/XLua/Gen/BF_TimelineSortingOderHelperWrap.cs new file mode 100644 index 000000000..1ee853eda --- /dev/null +++ b/Assets/XLua/Gen/BF_TimelineSortingOderHelperWrap.cs @@ -0,0 +1,143 @@ +#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 BFTimelineSortingOderHelperWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.TimelineSortingOderHelper); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSortingOrder", _m_SetSortingOrder); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetUIOrder", _m_SetUIOrder); + + + + + + 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.TimelineSortingOderHelper(); + 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.TimelineSortingOderHelper constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSortingOrder(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimelineSortingOderHelper gen_to_be_invoked = (BF.TimelineSortingOderHelper)translator.FastGetCSObj(L, 1); + + + + { + int _uiOrder = LuaAPI.xlua_tointeger(L, 2); + int _order = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetSortingOrder( _uiOrder, _order ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetUIOrder(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TimelineSortingOderHelper gen_to_be_invoked = (BF.TimelineSortingOderHelper)translator.FastGetCSObj(L, 1); + + + + { + int _uiOrder = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetUIOrder( _uiOrder ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_TutorialClickAreaWrap.cs b/Assets/XLua/Gen/BF_TutorialClickAreaWrap.cs new file mode 100644 index 000000000..31bc195c1 --- /dev/null +++ b/Assets/XLua/Gen/BF_TutorialClickAreaWrap.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 BFTutorialClickAreaWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.TutorialClickArea); + Utils.BeginObjectRegister(type, L, translator, 0, 7, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTargetTransform", _m_SetTargetTransform); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearTargetTransform", _m_ClearTargetTransform); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerDown", _m_OnPointerDown); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerUp", _m_OnPointerUp); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerEnter", _m_OnPointerEnter); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerExit", _m_OnPointerExit); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnCancel", _m_OnCancel); + + + + + + 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.TutorialClickArea(); + 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.TutorialClickArea constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTargetTransform(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TutorialClickArea gen_to_be_invoked = (BF.TutorialClickArea)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Transform _target = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + + gen_to_be_invoked.SetTargetTransform( _target ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearTargetTransform(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TutorialClickArea gen_to_be_invoked = (BF.TutorialClickArea)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearTargetTransform( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerDown(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TutorialClickArea gen_to_be_invoked = (BF.TutorialClickArea)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerDown( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerUp(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TutorialClickArea gen_to_be_invoked = (BF.TutorialClickArea)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerUp( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerEnter(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TutorialClickArea gen_to_be_invoked = (BF.TutorialClickArea)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerEnter( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerExit(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TutorialClickArea gen_to_be_invoked = (BF.TutorialClickArea)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerExit( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnCancel(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.TutorialClickArea gen_to_be_invoked = (BF.TutorialClickArea)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.BaseEventData _eventData = (UnityEngine.EventSystems.BaseEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.BaseEventData)); + + gen_to_be_invoked.OnCancel( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_UICoordinateHelperWrap.cs b/Assets/XLua/Gen/BF_UICoordinateHelperWrap.cs new file mode 100644 index 000000000..a867afa0b --- /dev/null +++ b/Assets/XLua/Gen/BF_UICoordinateHelperWrap.cs @@ -0,0 +1,233 @@ +#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 BFUICoordinateHelperWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.UICoordinateHelper); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 2, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetUICamera", _m_SetUICamera); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMainCamera", _m_SetMainCamera); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RectTransformScreenPointToLocalPointInRectangle", _m_RectTransformScreenPointToLocalPointInRectangle); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "WorldPointToLocalPointInRectangle", _m_WorldPointToLocalPointInRectangle); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "LocalPointX", _g_get_LocalPointX); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "LocalPointY", _g_get_LocalPointY); + + + + 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.UICoordinateHelper(); + 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.UICoordinateHelper constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetUICamera(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UICoordinateHelper gen_to_be_invoked = (BF.UICoordinateHelper)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 2, typeof(UnityEngine.Camera)); + + gen_to_be_invoked.SetUICamera( _camera ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMainCamera(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UICoordinateHelper gen_to_be_invoked = (BF.UICoordinateHelper)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 2, typeof(UnityEngine.Camera)); + + gen_to_be_invoked.SetMainCamera( _camera ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RectTransformScreenPointToLocalPointInRectangle(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UICoordinateHelper gen_to_be_invoked = (BF.UICoordinateHelper)translator.FastGetCSObj(L, 1); + + + + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.RectTransformScreenPointToLocalPointInRectangle( _x, _y ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_WorldPointToLocalPointInRectangle(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UICoordinateHelper gen_to_be_invoked = (BF.UICoordinateHelper)translator.FastGetCSObj(L, 1); + + + + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.WorldPointToLocalPointInRectangle( _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_LocalPointX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UICoordinateHelper gen_to_be_invoked = (BF.UICoordinateHelper)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.LocalPointX); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_LocalPointY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UICoordinateHelper gen_to_be_invoked = (BF.UICoordinateHelper)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.LocalPointY); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_UIDragEventWrap.cs b/Assets/XLua/Gen/BF_UIDragEventWrap.cs new file mode 100644 index 000000000..c98df533f --- /dev/null +++ b/Assets/XLua/Gen/BF_UIDragEventWrap.cs @@ -0,0 +1,113 @@ +#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 BFUIDragEventWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.UIDragEvent); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnDrag", _m_OnDrag); + + + + + + 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.UIDragEvent(); + 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.UIDragEvent constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIDragEvent gen_to_be_invoked = (BF.UIDragEvent)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_UIDynamicBrightEffectWrap.cs b/Assets/XLua/Gen/BF_UIDynamicBrightEffectWrap.cs new file mode 100644 index 000000000..37956a961 --- /dev/null +++ b/Assets/XLua/Gen/BF_UIDynamicBrightEffectWrap.cs @@ -0,0 +1,261 @@ +#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 BFUIDynamicBrightEffectWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.UIDynamicBrightEffect); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 3, 2); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ModifyMesh", _m_ModifyMesh); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMarterial", _m_SetMarterial); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetBright", _m_SetBright); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Brightness", _g_get_Brightness); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Brighting", _g_get_Brighting); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "effectmat", _g_get_effectmat); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Brightness", _s_set_Brightness); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "effectmat", _s_set_effectmat); + + + 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.UIDynamicBrightEffect(); + 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.UIDynamicBrightEffect constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ModifyMesh(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIDynamicBrightEffect gen_to_be_invoked = (BF.UIDynamicBrightEffect)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.UI.VertexHelper _vh = (UnityEngine.UI.VertexHelper)translator.GetObject(L, 2, typeof(UnityEngine.UI.VertexHelper)); + + gen_to_be_invoked.ModifyMesh( _vh ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMarterial(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIDynamicBrightEffect gen_to_be_invoked = (BF.UIDynamicBrightEffect)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + gen_to_be_invoked.SetMarterial( _material ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetBright(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIDynamicBrightEffect gen_to_be_invoked = (BF.UIDynamicBrightEffect)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _brightness = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.SetBright( _brightness ); + + + + return 0; + } + if(gen_param_count == 1) + { + + gen_to_be_invoked.SetBright( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BF.UIDynamicBrightEffect.SetBright!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Brightness(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UIDynamicBrightEffect gen_to_be_invoked = (BF.UIDynamicBrightEffect)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.Brightness); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Brighting(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UIDynamicBrightEffect gen_to_be_invoked = (BF.UIDynamicBrightEffect)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.Brighting); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_effectmat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UIDynamicBrightEffect gen_to_be_invoked = (BF.UIDynamicBrightEffect)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.effectmat); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Brightness(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UIDynamicBrightEffect gen_to_be_invoked = (BF.UIDynamicBrightEffect)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Brightness = (float)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_effectmat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UIDynamicBrightEffect gen_to_be_invoked = (BF.UIDynamicBrightEffect)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.effectmat = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_UIDynamicShinyEffectWrap.cs b/Assets/XLua/Gen/BF_UIDynamicShinyEffectWrap.cs new file mode 100644 index 000000000..787f3cbaf --- /dev/null +++ b/Assets/XLua/Gen/BF_UIDynamicShinyEffectWrap.cs @@ -0,0 +1,415 @@ +#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 BFUIDynamicShinyEffectWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.UIDynamicShinyEffect); + Utils.BeginObjectRegister(type, L, translator, 0, 5, 6, 6); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ModifyMesh", _m_ModifyMesh); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMarterial", _m_SetMarterial); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRepeat", _m_SetRepeat); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CancelRepeat", _m_CancelRepeat); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Play", _m_Play); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Location", _g_get_Location); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Width", _g_get_Width); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Softness", _g_get_Softness); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Highlight", _g_get_Highlight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Rotation", _g_get_Rotation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "effectmat", _g_get_effectmat); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Location", _s_set_Location); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Width", _s_set_Width); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Softness", _s_set_Softness); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Highlight", _s_set_Highlight); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Rotation", _s_set_Rotation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "effectmat", _s_set_effectmat); + + + 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.UIDynamicShinyEffect(); + 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.UIDynamicShinyEffect constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ModifyMesh(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIDynamicShinyEffect gen_to_be_invoked = (BF.UIDynamicShinyEffect)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.UI.VertexHelper _vh = (UnityEngine.UI.VertexHelper)translator.GetObject(L, 2, typeof(UnityEngine.UI.VertexHelper)); + + gen_to_be_invoked.ModifyMesh( _vh ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMarterial(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIDynamicShinyEffect gen_to_be_invoked = (BF.UIDynamicShinyEffect)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + gen_to_be_invoked.SetMarterial( _material ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRepeat(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIDynamicShinyEffect gen_to_be_invoked = (BF.UIDynamicShinyEffect)translator.FastGetCSObj(L, 1); + + + + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + float _intervalTime = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetRepeat( _duration, _intervalTime ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CancelRepeat(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIDynamicShinyEffect gen_to_be_invoked = (BF.UIDynamicShinyEffect)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CancelRepeat( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Play(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIDynamicShinyEffect gen_to_be_invoked = (BF.UIDynamicShinyEffect)translator.FastGetCSObj(L, 1); + + + + { + float _durationParam = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.Play( _durationParam ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Location(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UIDynamicShinyEffect gen_to_be_invoked = (BF.UIDynamicShinyEffect)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.Location); + } 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.UIDynamicShinyEffect gen_to_be_invoked = (BF.UIDynamicShinyEffect)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(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_Softness(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UIDynamicShinyEffect gen_to_be_invoked = (BF.UIDynamicShinyEffect)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.Softness); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Highlight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UIDynamicShinyEffect gen_to_be_invoked = (BF.UIDynamicShinyEffect)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.Highlight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Rotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UIDynamicShinyEffect gen_to_be_invoked = (BF.UIDynamicShinyEffect)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.Rotation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_effectmat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UIDynamicShinyEffect gen_to_be_invoked = (BF.UIDynamicShinyEffect)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.effectmat); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Location(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UIDynamicShinyEffect gen_to_be_invoked = (BF.UIDynamicShinyEffect)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Location = (float)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_Width(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UIDynamicShinyEffect gen_to_be_invoked = (BF.UIDynamicShinyEffect)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Width = (float)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_Softness(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UIDynamicShinyEffect gen_to_be_invoked = (BF.UIDynamicShinyEffect)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Softness = (float)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_Highlight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UIDynamicShinyEffect gen_to_be_invoked = (BF.UIDynamicShinyEffect)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Highlight = (float)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_Rotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UIDynamicShinyEffect gen_to_be_invoked = (BF.UIDynamicShinyEffect)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Rotation = (float)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_effectmat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UIDynamicShinyEffect gen_to_be_invoked = (BF.UIDynamicShinyEffect)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.effectmat = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_UIEraserTextureWrap.cs b/Assets/XLua/Gen/BF_UIEraserTextureWrap.cs new file mode 100644 index 000000000..a50811579 --- /dev/null +++ b/Assets/XLua/Gen/BF_UIEraserTextureWrap.cs @@ -0,0 +1,349 @@ +#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 BFUIEraserTextureWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.UIEraserTexture); + Utils.BeginObjectRegister(type, L, translator, 0, 7, 2, 2); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddTouchEventListener", _m_AddTouchEventListener); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveEventListener", _m_RemoveEventListener); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerDown", _m_OnPointerDown); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerUp", _m_OnPointerUp); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnCancel", _m_OnCancel); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ContainsPos", _m_ContainsPos); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Reset", _m_Reset); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "brushScale", _g_get_brushScale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "eraseScale", _g_get_eraseScale); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "brushScale", _s_set_brushScale); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "eraseScale", _s_set_eraseScale); + + + 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.UIEraserTexture(); + 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.UIEraserTexture constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddTouchEventListener(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIEraserTexture gen_to_be_invoked = (BF.UIEraserTexture)translator.FastGetCSObj(L, 1); + + + + { + System.Action _func = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.AddTouchEventListener( _func ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveEventListener(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIEraserTexture gen_to_be_invoked = (BF.UIEraserTexture)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RemoveEventListener( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerDown(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIEraserTexture gen_to_be_invoked = (BF.UIEraserTexture)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerDown( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerUp(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIEraserTexture gen_to_be_invoked = (BF.UIEraserTexture)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerUp( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnCancel(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIEraserTexture gen_to_be_invoked = (BF.UIEraserTexture)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.BaseEventData _eventData = (UnityEngine.EventSystems.BaseEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.BaseEventData)); + + gen_to_be_invoked.OnCancel( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ContainsPos(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIEraserTexture gen_to_be_invoked = (BF.UIEraserTexture)translator.FastGetCSObj(L, 1); + + + + { + int _x = LuaAPI.xlua_tointeger(L, 2); + int _y = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.ContainsPos( _x, _y ); + 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_Reset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIEraserTexture gen_to_be_invoked = (BF.UIEraserTexture)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Reset( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_brushScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UIEraserTexture gen_to_be_invoked = (BF.UIEraserTexture)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.brushScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_eraseScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UIEraserTexture gen_to_be_invoked = (BF.UIEraserTexture)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.eraseScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_brushScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UIEraserTexture gen_to_be_invoked = (BF.UIEraserTexture)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.brushScale = 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_eraseScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UIEraserTexture gen_to_be_invoked = (BF.UIEraserTexture)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.eraseScale = (float)LuaAPI.lua_tonumber(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_UIHelperWrap.cs b/Assets/XLua/Gen/BF_UIHelperWrap.cs new file mode 100644 index 000000000..e46a6bdf4 --- /dev/null +++ b/Assets/XLua/Gen/BF_UIHelperWrap.cs @@ -0,0 +1,695 @@ +#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 BFUIHelperWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.UIHelper); + Utils.BeginObjectRegister(type, L, translator, 0, 17, 5, 2); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetInit", _m_SetInit); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHasInitDefaultNotchScreenHeight", _m_GetHasInitDefaultNotchScreenHeight); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNotchScreenNodeCount", _m_GetNotchScreenNodeCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNotchScreenNodeGameObject", _m_GetNotchScreenNodeGameObject); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNotchScreenNodeAdjustHeight", _m_GetNotchScreenNodeAdjustHeight); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetIsHaveNotchScreenNodeGameObject", _m_GetIsHaveNotchScreenNodeGameObject); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CacheAnchoredPosition", _m_CacheAnchoredPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CacheAnchorMin", _m_CacheAnchorMin); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CacheAnchorMax", _m_CacheAnchorMax); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CacheOffsetMax", _m_CacheOffsetMax); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CacheOffsetMin", _m_CacheOffsetMin); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetOffsetMax", _m_SetOffsetMax); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetOffsetMin", _m_SetOffsetMin); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAnchoredPosition", _m_SetAnchoredPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSortingOrder", _m_SetSortingOrder); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddEffect", _m_AddEffect); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveEffect", _m_RemoveEffect); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PositionX", _g_get_PositionX); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PositionY", _g_get_PositionY); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PositionZ", _g_get_PositionZ); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "EffectList", _g_get_EffectList); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "NotchScreenNodeList", _g_get_NotchScreenNodeList); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "EffectList", _s_set_EffectList); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "NotchScreenNodeList", _s_set_NotchScreenNodeList); + + + 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.UIHelper(); + 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.UIHelper constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetInit(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIHelper gen_to_be_invoked = (BF.UIHelper)translator.FastGetCSObj(L, 1); + + + + { + bool _init = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.SetInit( _init ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetHasInitDefaultNotchScreenHeight(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIHelper gen_to_be_invoked = (BF.UIHelper)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetHasInitDefaultNotchScreenHeight( ); + 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_GetNotchScreenNodeCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIHelper gen_to_be_invoked = (BF.UIHelper)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetNotchScreenNodeCount( ); + 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_GetNotchScreenNodeGameObject(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIHelper gen_to_be_invoked = (BF.UIHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetNotchScreenNodeGameObject( _index ); + 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_GetNotchScreenNodeAdjustHeight(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIHelper gen_to_be_invoked = (BF.UIHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetNotchScreenNodeAdjustHeight( _index ); + LuaAPI.lua_pushnumber(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_GetIsHaveNotchScreenNodeGameObject(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIHelper gen_to_be_invoked = (BF.UIHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetIsHaveNotchScreenNodeGameObject( _index ); + 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_CacheAnchoredPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIHelper gen_to_be_invoked = (BF.UIHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.CacheAnchoredPosition( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CacheAnchorMin(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIHelper gen_to_be_invoked = (BF.UIHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.CacheAnchorMin( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CacheAnchorMax(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIHelper gen_to_be_invoked = (BF.UIHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.CacheAnchorMax( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CacheOffsetMax(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIHelper gen_to_be_invoked = (BF.UIHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.CacheOffsetMax( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CacheOffsetMin(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIHelper gen_to_be_invoked = (BF.UIHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.CacheOffsetMin( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetOffsetMax(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIHelper gen_to_be_invoked = (BF.UIHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.SetOffsetMax( _index, _x, _y ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetOffsetMin(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIHelper gen_to_be_invoked = (BF.UIHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.SetOffsetMin( _index, _x, _y ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAnchoredPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIHelper gen_to_be_invoked = (BF.UIHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.SetAnchoredPosition( _index, _x, _y ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSortingOrder(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIHelper gen_to_be_invoked = (BF.UIHelper)translator.FastGetCSObj(L, 1); + + + + { + int _uiOrder = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetSortingOrder( _uiOrder ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddEffect(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIHelper gen_to_be_invoked = (BF.UIHelper)translator.FastGetCSObj(L, 1); + + + + { + BF.BaseSortingOrderHelper _helper = (BF.BaseSortingOrderHelper)translator.GetObject(L, 2, typeof(BF.BaseSortingOrderHelper)); + int _uiOrder = LuaAPI.xlua_tointeger(L, 3); + int _order = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.AddEffect( _helper, _uiOrder, _order ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveEffect(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UIHelper gen_to_be_invoked = (BF.UIHelper)translator.FastGetCSObj(L, 1); + + + + { + BF.BaseSortingOrderHelper _helper = (BF.BaseSortingOrderHelper)translator.GetObject(L, 2, typeof(BF.BaseSortingOrderHelper)); + + gen_to_be_invoked.RemoveEffect( _helper ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PositionX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UIHelper gen_to_be_invoked = (BF.UIHelper)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.PositionX); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PositionY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UIHelper gen_to_be_invoked = (BF.UIHelper)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.PositionY); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PositionZ(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UIHelper gen_to_be_invoked = (BF.UIHelper)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.PositionZ); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_EffectList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UIHelper gen_to_be_invoked = (BF.UIHelper)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.EffectList); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_NotchScreenNodeList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UIHelper gen_to_be_invoked = (BF.UIHelper)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.NotchScreenNodeList); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_EffectList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UIHelper gen_to_be_invoked = (BF.UIHelper)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.EffectList = (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; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_NotchScreenNodeList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UIHelper gen_to_be_invoked = (BF.UIHelper)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.NotchScreenNodeList = (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/BF_UISpineHelperWrap.cs b/Assets/XLua/Gen/BF_UISpineHelperWrap.cs new file mode 100644 index 000000000..ecda6f8d4 --- /dev/null +++ b/Assets/XLua/Gen/BF_UISpineHelperWrap.cs @@ -0,0 +1,142 @@ +#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 BFUISpineHelperWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.UISpineHelper); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Reload", _m_Reload); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAnimationKeyFrameTime", _m_GetAnimationKeyFrameTime); + + + + + + 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.UISpineHelper(); + 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.UISpineHelper constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Reload(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UISpineHelper gen_to_be_invoked = (BF.UISpineHelper)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Reload( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetAnimationKeyFrameTime(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UISpineHelper gen_to_be_invoked = (BF.UISpineHelper)translator.FastGetCSObj(L, 1); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetAnimationKeyFrameTime( _name ); + 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/BF_UITouchEventWrap.cs b/Assets/XLua/Gen/BF_UITouchEventWrap.cs new file mode 100644 index 000000000..63fd73db7 --- /dev/null +++ b/Assets/XLua/Gen/BF_UITouchEventWrap.cs @@ -0,0 +1,459 @@ +#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 BFUITouchEventWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.UITouchEvent); + Utils.BeginObjectRegister(type, L, translator, 0, 11, 1, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddTouchEventListener", _m_AddTouchEventListener); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveEventListener", _m_RemoveEventListener); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetShowClickAnimation", _m_SetShowClickAnimation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetShowClickAnimation", _m_GetShowClickAnimation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTouchEnable", _m_SetTouchEnable); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "StopTouchAnimation", _m_StopTouchAnimation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerDown", _m_OnPointerDown); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerUp", _m_OnPointerUp); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerEnter", _m_OnPointerEnter); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerExit", _m_OnPointerExit); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnCancel", _m_OnCancel); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsShowClickAnimation", _g_get_IsShowClickAnimation); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "IsShowClickAnimation", _s_set_IsShowClickAnimation); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 1, 1); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "disableClickEvent", _g_get_disableClickEvent); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "disableClickEvent", _s_set_disableClickEvent); + + + 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.UITouchEvent(); + 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.UITouchEvent constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddTouchEventListener(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UITouchEvent gen_to_be_invoked = (BF.UITouchEvent)translator.FastGetCSObj(L, 1); + + + + { + System.Action _func = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.AddTouchEventListener( _func ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveEventListener(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UITouchEvent gen_to_be_invoked = (BF.UITouchEvent)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RemoveEventListener( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetShowClickAnimation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UITouchEvent gen_to_be_invoked = (BF.UITouchEvent)translator.FastGetCSObj(L, 1); + + + + { + bool _isShow = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.SetShowClickAnimation( _isShow ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetShowClickAnimation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UITouchEvent gen_to_be_invoked = (BF.UITouchEvent)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetShowClickAnimation( ); + 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_SetTouchEnable(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UITouchEvent gen_to_be_invoked = (BF.UITouchEvent)translator.FastGetCSObj(L, 1); + + + + { + bool _enable = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.SetTouchEnable( _enable ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_StopTouchAnimation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UITouchEvent gen_to_be_invoked = (BF.UITouchEvent)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.StopTouchAnimation( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerDown(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UITouchEvent gen_to_be_invoked = (BF.UITouchEvent)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerDown( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerUp(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UITouchEvent gen_to_be_invoked = (BF.UITouchEvent)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerUp( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerEnter(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UITouchEvent gen_to_be_invoked = (BF.UITouchEvent)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerEnter( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerExit(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UITouchEvent gen_to_be_invoked = (BF.UITouchEvent)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerExit( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnCancel(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.UITouchEvent gen_to_be_invoked = (BF.UITouchEvent)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.BaseEventData _eventData = (UnityEngine.EventSystems.BaseEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.BaseEventData)); + + gen_to_be_invoked.OnCancel( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsShowClickAnimation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UITouchEvent gen_to_be_invoked = (BF.UITouchEvent)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsShowClickAnimation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_disableClickEvent(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, BF.UITouchEvent.disableClickEvent); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_IsShowClickAnimation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UITouchEvent gen_to_be_invoked = (BF.UITouchEvent)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.IsShowClickAnimation = 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_disableClickEvent(RealStatePtr L) + { + try { + + BF.UITouchEvent.disableClickEvent = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_URPManagerWrap.cs b/Assets/XLua/Gen/BF_URPManagerWrap.cs new file mode 100644 index 000000000..ab82efd22 --- /dev/null +++ b/Assets/XLua/Gen/BF_URPManagerWrap.cs @@ -0,0 +1,239 @@ +#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 BFURPManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.URPManager); + Utils.BeginObjectRegister(type, L, translator, 0, 5, 0, 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, "URPAddAdditionalCamera", _m_URPAddAdditionalCamera); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "URPRemoveAdditionalCamera", _m_URPRemoveAdditionalCamera); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "URPClearAdditionalCamera", _m_URPClearAdditionalCamera); + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Create", _m_Create_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "BF.URPManager does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Create_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = BF.URPManager.Create( ); + 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_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.URPManager gen_to_be_invoked = (BF.URPManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Destroy(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.URPManager gen_to_be_invoked = (BF.URPManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Destroy( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_URPAddAdditionalCamera(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.URPManager gen_to_be_invoked = (BF.URPManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Camera _mainCamera = (UnityEngine.Camera)translator.GetObject(L, 2, typeof(UnityEngine.Camera)); + UnityEngine.Camera _additionalCamera = (UnityEngine.Camera)translator.GetObject(L, 3, typeof(UnityEngine.Camera)); + + gen_to_be_invoked.URPAddAdditionalCamera( _mainCamera, _additionalCamera ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_URPRemoveAdditionalCamera(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.URPManager gen_to_be_invoked = (BF.URPManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Camera _mainCamera = (UnityEngine.Camera)translator.GetObject(L, 2, typeof(UnityEngine.Camera)); + UnityEngine.Camera _additionalCamera = (UnityEngine.Camera)translator.GetObject(L, 3, typeof(UnityEngine.Camera)); + + gen_to_be_invoked.URPRemoveAdditionalCamera( _mainCamera, _additionalCamera ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_URPClearAdditionalCamera(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.URPManager gen_to_be_invoked = (BF.URPManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Camera _mainCamera = (UnityEngine.Camera)translator.GetObject(L, 2, typeof(UnityEngine.Camera)); + + gen_to_be_invoked.URPClearAdditionalCamera( _mainCamera ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_UVAnimationGraphicWrap.cs b/Assets/XLua/Gen/BF_UVAnimationGraphicWrap.cs new file mode 100644 index 000000000..d3ebfafaa --- /dev/null +++ b/Assets/XLua/Gen/BF_UVAnimationGraphicWrap.cs @@ -0,0 +1,207 @@ +#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 BFUVAnimationGraphicWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.UVAnimationGraphic); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 5, 3); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "MainSprite", _g_get_MainSprite); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "CellAmount", _g_get_CellAmount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Speed", _g_get_Speed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mainTexture", _g_get_mainTexture); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "material", _g_get_material); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "MainSprite", _s_set_MainSprite); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "CellAmount", _s_set_CellAmount); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Speed", _s_set_Speed); + + + 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.UVAnimationGraphic(); + 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.UVAnimationGraphic constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_MainSprite(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UVAnimationGraphic gen_to_be_invoked = (BF.UVAnimationGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.MainSprite); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_CellAmount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UVAnimationGraphic gen_to_be_invoked = (BF.UVAnimationGraphic)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.CellAmount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Speed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UVAnimationGraphic gen_to_be_invoked = (BF.UVAnimationGraphic)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.Speed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mainTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UVAnimationGraphic gen_to_be_invoked = (BF.UVAnimationGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.mainTexture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_material(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UVAnimationGraphic gen_to_be_invoked = (BF.UVAnimationGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.material); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_MainSprite(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UVAnimationGraphic gen_to_be_invoked = (BF.UVAnimationGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.MainSprite = (UnityEngine.Sprite)translator.GetObject(L, 2, typeof(UnityEngine.Sprite)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_CellAmount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UVAnimationGraphic gen_to_be_invoked = (BF.UVAnimationGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.CellAmount = 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_Speed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.UVAnimationGraphic gen_to_be_invoked = (BF.UVAnimationGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Speed = (float)LuaAPI.lua_tonumber(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_UtilsWrap.cs b/Assets/XLua/Gen/BF_UtilsWrap.cs new file mode 100644 index 000000000..c9e32c076 --- /dev/null +++ b/Assets/XLua/Gen/BF_UtilsWrap.cs @@ -0,0 +1,866 @@ +#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 BFUtilsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.Utils); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 28, 1, 1); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetFreeChar", _m_GetFreeChar_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetConfigChar", _m_GetConfigChar_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IsNull", _m_IsNull_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetTransformPath", _m_GetTransformPath_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetAssetPathByFullPath", _m_GetAssetPathByFullPath_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RectTransformScreenPointToLocalPointInRectangle", _m_RectTransformScreenPointToLocalPointInRectangle_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LocalPointInRectangleToWorld", _m_LocalPointInRectangleToWorld_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RectangleContainsScreenPoint", _m_RectangleContainsScreenPoint_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "KillDOTween", _m_KillDOTween_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetDOTweenTimeScale", _m_SetDOTweenTimeScale_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "NameToLayer", _m_NameToLayer_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetLayoutAlignment", _m_SetLayoutAlignment_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "TransformPoint2World", _m_TransformPoint2World_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "TransformWorld2Point", _m_TransformWorld2Point_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetIP", _m_GetIP_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetStringConfigPathList", _m_GetStringConfigPathList_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RayCast", _m_RayCast_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "BKDRHash", _m_BKDRHash_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ParseHtmlString", _m_ParseHtmlString_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetCurrentAnimationHash", _m_GetCurrentAnimationHash_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetEnvironmentTickCount", _m_GetEnvironmentTickCount_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetDataSecretKey", _m_GetDataSecretKey_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetRewardNumber", _m_GetRewardNumber_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "DOBFSliderValue", _m_DOBFSliderValue_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetAndroidSignKeyHash", _m_GetAndroidSignKeyHash_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IsSpecialChar", _m_IsSpecialChar_xlua_st_); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FORWARD_SLASH", BF.Utils.FORWARD_SLASH); + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "CustomSpecialPatternStr", _g_get_CustomSpecialPatternStr); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "CustomSpecialPatternStr", _s_set_CustomSpecialPatternStr); + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "BF.Utils does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetFreeChar_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = BF.Utils.GetFreeChar( ); + 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_GetConfigChar_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = BF.Utils.GetConfigChar( ); + 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_IsNull_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Object _o = (UnityEngine.Object)translator.GetObject(L, 1, typeof(UnityEngine.Object)); + + var gen_ret = BF.Utils.IsNull( _o ); + 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_GetTransformPath_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Transform _trans = (UnityEngine.Transform)translator.GetObject(L, 1, typeof(UnityEngine.Transform)); + UnityEngine.Transform _parentTrans = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + string _path = LuaAPI.lua_tostring(L, 3); + + BF.Utils.GetTransformPath( _trans, _parentTrans, ref _path ); + LuaAPI.lua_pushstring(L, _path); + + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetAssetPathByFullPath_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _fullPath = LuaAPI.lua_tostring(L, 1); + + var gen_ret = BF.Utils.GetAssetPathByFullPath( _fullPath ); + 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 _m_RectTransformScreenPointToLocalPointInRectangle_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.RectTransform _rt = (UnityEngine.RectTransform)translator.GetObject(L, 1, typeof(UnityEngine.RectTransform)); + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Camera _cam = (UnityEngine.Camera)translator.GetObject(L, 4, typeof(UnityEngine.Camera)); + + var gen_ret = BF.Utils.RectTransformScreenPointToLocalPointInRectangle( _rt, _x, _y, _cam ); + translator.PushUnityEngineVector2(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_LocalPointInRectangleToWorld_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.RectTransform _rt = (UnityEngine.RectTransform)translator.GetObject(L, 1, typeof(UnityEngine.RectTransform)); + float _planeZ = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Camera _uiCam = (UnityEngine.Camera)translator.GetObject(L, 3, typeof(UnityEngine.Camera)); + UnityEngine.Camera _main = (UnityEngine.Camera)translator.GetObject(L, 4, typeof(UnityEngine.Camera)); + + var gen_ret = BF.Utils.LocalPointInRectangleToWorld( _rt, _planeZ, _uiCam, _main ); + translator.PushUnityEngineVector3(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_RectangleContainsScreenPoint_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.RectTransform _rt = (UnityEngine.RectTransform)translator.GetObject(L, 1, typeof(UnityEngine.RectTransform)); + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Camera _cam = (UnityEngine.Camera)translator.GetObject(L, 4, typeof(UnityEngine.Camera)); + + var gen_ret = BF.Utils.RectangleContainsScreenPoint( _rt, _x, _y, _cam ); + 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_KillDOTween_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + int _id = LuaAPI.xlua_tointeger(L, 1); + bool _complete = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = BF.Utils.KillDOTween( _id, _complete ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _id = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = BF.Utils.KillDOTween( _id ); + LuaAPI.xlua_pushinteger(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.Utils.KillDOTween!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetDOTweenTimeScale_xlua_st_(RealStatePtr L) + { + try { + + + + + { + int _id = LuaAPI.xlua_tointeger(L, 1); + float _timeScale = (float)LuaAPI.lua_tonumber(L, 2); + + BF.Utils.SetDOTweenTimeScale( _id, _timeScale ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_NameToLayer_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _name = LuaAPI.lua_tostring(L, 1); + + var gen_ret = BF.Utils.NameToLayer( _name ); + 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_SetLayoutAlignment_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.UI.LayoutGroup _layout = (UnityEngine.UI.LayoutGroup)translator.GetObject(L, 1, typeof(UnityEngine.UI.LayoutGroup)); + int _enum_type = LuaAPI.xlua_tointeger(L, 2); + + BF.Utils.SetLayoutAlignment( _layout, _enum_type ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TransformPoint2World_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Transform _transform = (UnityEngine.Transform)translator.GetObject(L, 1, typeof(UnityEngine.Transform)); + UnityEngine.Vector3 _point;translator.Get(L, 2, out _point); + + var gen_ret = BF.Utils.TransformPoint2World( _transform, _point ); + translator.PushUnityEngineVector3(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_TransformWorld2Point_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Transform _transform = (UnityEngine.Transform)translator.GetObject(L, 1, typeof(UnityEngine.Transform)); + UnityEngine.Vector3 _point;translator.Get(L, 2, out _point); + + var gen_ret = BF.Utils.TransformWorld2Point( _transform, _point ); + translator.PushUnityEngineVector3(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_GetIP_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.Utils.GetIP( ); + 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 _m_GetStringConfigPathList_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = BF.Utils.GetStringConfigPathList( ); + 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_RayCast_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + float _distance = (float)LuaAPI.lua_tonumber(L, 2); + int _layer = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.RaycastHit _raycastHit; + + var gen_ret = BF.Utils.RayCast( _ray, _distance, _layer, out _raycastHit ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _raycastHit); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_BKDRHash_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _name = LuaAPI.lua_tostring(L, 1); + + var gen_ret = BF.Utils.BKDRHash( _name ); + LuaAPI.xlua_pushuint(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_ParseHtmlString_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _htmlString = LuaAPI.lua_tostring(L, 1); + + var gen_ret = BF.Utils.ParseHtmlString( _htmlString ); + translator.PushUnityEngineColor(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_GetCurrentAnimationHash_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + UnityEngine.Animator _animator = (UnityEngine.Animator)translator.GetObject(L, 1, typeof(UnityEngine.Animator)); + int _layer = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = BF.Utils.GetCurrentAnimationHash( _animator, _layer ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + UnityEngine.Animator _animator = (UnityEngine.Animator)translator.GetObject(L, 1, typeof(UnityEngine.Animator)); + + var gen_ret = BF.Utils.GetCurrentAnimationHash( _animator ); + LuaAPI.xlua_pushinteger(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.Utils.GetCurrentAnimationHash!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetEnvironmentTickCount_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.Utils.GetEnvironmentTickCount( ); + 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_GetDataSecretKey_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.Utils.GetDataSecretKey( ); + 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 _m_GetRewardNumber_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _str = LuaAPI.lua_tostring(L, 1); + + var gen_ret = BF.Utils.GetRewardNumber( _str ); + LuaAPI.lua_pushint64(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_DOBFSliderValue_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + BF.BFSlider _target = (BF.BFSlider)translator.GetObject(L, 1, typeof(BF.BFSlider)); + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapping = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = BF.Utils.DOBFSliderValue( _target, _endValue, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + BF.BFSlider _target = (BF.BFSlider)translator.GetObject(L, 1, typeof(BF.BFSlider)); + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = BF.Utils.DOBFSliderValue( _target, _endValue, _duration ); + 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.Utils.DOBFSliderValue!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetAndroidSignKeyHash_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = BF.Utils.GetAndroidSignKeyHash( ); + 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 _m_IsSpecialChar_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _str = LuaAPI.lua_tostring(L, 1); + bool _useDefaultPattern = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = BF.Utils.IsSpecialChar( _str, _useDefaultPattern ); + 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 _g_get_CustomSpecialPatternStr(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, BF.Utils.CustomSpecialPatternStr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_CustomSpecialPatternStr(RealStatePtr L) + { + try { + + BF.Utils.CustomSpecialPatternStr = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/BF_VerticalScrollRectOldWrap.cs b/Assets/XLua/Gen/BF_VerticalScrollRectOldWrap.cs new file mode 100644 index 000000000..fb05f3bdc --- /dev/null +++ b/Assets/XLua/Gen/BF_VerticalScrollRectOldWrap.cs @@ -0,0 +1,141 @@ +#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 BFVerticalScrollRectOldWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.VerticalScrollRectOld); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshRealShowIndex", _m_RefreshRealShowIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsNotFull", _m_IsNotFull); + + + + + + 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.VerticalScrollRectOld(); + 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.VerticalScrollRectOld constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RefreshRealShowIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.VerticalScrollRectOld gen_to_be_invoked = (BF.VerticalScrollRectOld)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RefreshRealShowIndex( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsNotFull(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.VerticalScrollRectOld gen_to_be_invoked = (BF.VerticalScrollRectOld)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsNotFull( ); + LuaAPI.lua_pushboolean(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_WeaponHelperWrap.cs b/Assets/XLua/Gen/BF_WeaponHelperWrap.cs new file mode 100644 index 000000000..f1a8e649c --- /dev/null +++ b/Assets/XLua/Gen/BF_WeaponHelperWrap.cs @@ -0,0 +1,647 @@ +#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 BFWeaponHelperWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BF.WeaponHelper); + Utils.BeginObjectRegister(type, L, translator, 0, 14, 6, 3); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetModelObject", _m_GetModelObject); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetModelHashCode", _m_GetModelHashCode); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetListCount", _m_GetListCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetGameObjectByIndex", _m_GetGameObjectByIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashNameByIndex", _m_GetHashNameByIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CacheLocalPosition", _m_CacheLocalPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLocalPosition", _m_SetLocalPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CachePosition", _m_CachePosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPosition", _m_SetPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLocalEulerAngles", _m_SetLocalEulerAngles); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLocalScale", _m_SetLocalScale); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMainModelLocalPosition", _m_SetMainModelLocalPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetStateTime", _m_GetStateTime); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetStateKeyFrame", _m_GetStateKeyFrame); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PositionX", _g_get_PositionX); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PositionY", _g_get_PositionY); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PositionZ", _g_get_PositionZ); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "modelObject", _g_get_modelObject); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "objectList", _g_get_objectList); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "animationList", _g_get_animationList); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "modelObject", _s_set_modelObject); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "objectList", _s_set_objectList); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "animationList", _s_set_animationList); + + + 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.WeaponHelper(); + 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.WeaponHelper constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetModelObject(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.WeaponHelper gen_to_be_invoked = (BF.WeaponHelper)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetModelObject( ); + 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_GetModelHashCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.WeaponHelper gen_to_be_invoked = (BF.WeaponHelper)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetModelHashCode( ); + 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_GetListCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.WeaponHelper gen_to_be_invoked = (BF.WeaponHelper)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetListCount( ); + 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_GetGameObjectByIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.WeaponHelper gen_to_be_invoked = (BF.WeaponHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetGameObjectByIndex( _index ); + 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_GetHashNameByIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.WeaponHelper gen_to_be_invoked = (BF.WeaponHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetHashNameByIndex( _index ); + LuaAPI.xlua_pushuint(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_CacheLocalPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.WeaponHelper gen_to_be_invoked = (BF.WeaponHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.CacheLocalPosition( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLocalPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.WeaponHelper gen_to_be_invoked = (BF.WeaponHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + float _z = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.SetLocalPosition( _index, _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CachePosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.WeaponHelper gen_to_be_invoked = (BF.WeaponHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.CachePosition( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.WeaponHelper gen_to_be_invoked = (BF.WeaponHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + float _z = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.SetPosition( _index, _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLocalEulerAngles(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.WeaponHelper gen_to_be_invoked = (BF.WeaponHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + float _z = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.SetLocalEulerAngles( _index, _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLocalScale(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.WeaponHelper gen_to_be_invoked = (BF.WeaponHelper)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _x = (float)LuaAPI.lua_tonumber(L, 3); + float _y = (float)LuaAPI.lua_tonumber(L, 4); + float _z = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.SetLocalScale( _index, _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMainModelLocalPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.WeaponHelper gen_to_be_invoked = (BF.WeaponHelper)translator.FastGetCSObj(L, 1); + + + + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.SetMainModelLocalPosition( _x, _y, _z ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetStateTime(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.WeaponHelper gen_to_be_invoked = (BF.WeaponHelper)translator.FastGetCSObj(L, 1); + + + + { + uint _index = LuaAPI.xlua_touint(L, 2); + + var gen_ret = gen_to_be_invoked.GetStateTime( _index ); + LuaAPI.lua_pushnumber(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_GetStateKeyFrame(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BF.WeaponHelper gen_to_be_invoked = (BF.WeaponHelper)translator.FastGetCSObj(L, 1); + + + + { + uint _hashName = LuaAPI.xlua_touint(L, 2); + int _index = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.GetStateKeyFrame( _hashName, _index ); + LuaAPI.xlua_pushuint(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_PositionX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.WeaponHelper gen_to_be_invoked = (BF.WeaponHelper)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.PositionX); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PositionY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.WeaponHelper gen_to_be_invoked = (BF.WeaponHelper)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.PositionY); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PositionZ(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.WeaponHelper gen_to_be_invoked = (BF.WeaponHelper)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.PositionZ); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_modelObject(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.WeaponHelper gen_to_be_invoked = (BF.WeaponHelper)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.modelObject); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_objectList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.WeaponHelper gen_to_be_invoked = (BF.WeaponHelper)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.objectList); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_animationList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.WeaponHelper gen_to_be_invoked = (BF.WeaponHelper)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.animationList); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_modelObject(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.WeaponHelper gen_to_be_invoked = (BF.WeaponHelper)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.modelObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_objectList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.WeaponHelper gen_to_be_invoked = (BF.WeaponHelper)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.objectList = (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; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_animationList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BF.WeaponHelper gen_to_be_invoked = (BF.WeaponHelper)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.animationList = (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/BestHTTP_Connections_HTTP2_HTTP2ResponseWrap.cs b/Assets/XLua/Gen/BestHTTP_Connections_HTTP2_HTTP2ResponseWrap.cs new file mode 100644 index 000000000..74dd6dd8d --- /dev/null +++ b/Assets/XLua/Gen/BestHTTP_Connections_HTTP2_HTTP2ResponseWrap.cs @@ -0,0 +1,116 @@ +#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 BestHTTPConnectionsHTTP2HTTP2ResponseWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BestHTTP.Connections.HTTP2.HTTP2Response); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 0); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ExpectedContentLength", _g_get_ExpectedContentLength); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsCompressed", _g_get_IsCompressed); + + + + 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 && translator.Assignable(L, 2) && LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + BestHTTP.HTTPRequest _request = (BestHTTP.HTTPRequest)translator.GetObject(L, 2, typeof(BestHTTP.HTTPRequest)); + bool _isFromCache = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = new BestHTTP.Connections.HTTP2.HTTP2Response(_request, _isFromCache); + 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 BestHTTP.Connections.HTTP2.HTTP2Response constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ExpectedContentLength(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.Connections.HTTP2.HTTP2Response gen_to_be_invoked = (BestHTTP.Connections.HTTP2.HTTP2Response)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.ExpectedContentLength); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsCompressed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.Connections.HTTP2.HTTP2Response gen_to_be_invoked = (BestHTTP.Connections.HTTP2.HTTP2Response)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsCompressed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/BestHTTP_Forms_HTTPFormBaseWrap.cs b/Assets/XLua/Gen/BestHTTP_Forms_HTTPFormBaseWrap.cs new file mode 100644 index 000000000..0257b9085 --- /dev/null +++ b/Assets/XLua/Gen/BestHTTP_Forms_HTTPFormBaseWrap.cs @@ -0,0 +1,367 @@ +#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 BestHTTPFormsHTTPFormBaseWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BestHTTP.Forms.HTTPFormBase); + Utils.BeginObjectRegister(type, L, translator, 0, 5, 5, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddBinaryData", _m_AddBinaryData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddField", _m_AddField); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CopyFrom", _m_CopyFrom); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PrepareRequest", _m_PrepareRequest); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetData", _m_GetData); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Fields", _g_get_Fields); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsEmpty", _g_get_IsEmpty); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsChanged", _g_get_IsChanged); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "HasBinary", _g_get_HasBinary); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "HasLongValue", _g_get_HasLongValue); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Fields", _s_set_Fields); + + + 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 BestHTTP.Forms.HTTPFormBase(); + 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 BestHTTP.Forms.HTTPFormBase constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddBinaryData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.Forms.HTTPFormBase gen_to_be_invoked = (BestHTTP.Forms.HTTPFormBase)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 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 _fieldName = LuaAPI.lua_tostring(L, 2); + byte[] _content = LuaAPI.lua_tobytes(L, 3); + + gen_to_be_invoked.AddBinaryData( _fieldName, _content ); + + + + return 0; + } + if(gen_param_count == 4&& (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)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)) + { + string _fieldName = LuaAPI.lua_tostring(L, 2); + byte[] _content = LuaAPI.lua_tobytes(L, 3); + string _fileName = LuaAPI.lua_tostring(L, 4); + + gen_to_be_invoked.AddBinaryData( _fieldName, _content, _fileName ); + + + + return 0; + } + if(gen_param_count == 5&& (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)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 5) || LuaAPI.lua_type(L, 5) == LuaTypes.LUA_TSTRING)) + { + string _fieldName = LuaAPI.lua_tostring(L, 2); + byte[] _content = LuaAPI.lua_tobytes(L, 3); + string _fileName = LuaAPI.lua_tostring(L, 4); + string _mimeType = LuaAPI.lua_tostring(L, 5); + + gen_to_be_invoked.AddBinaryData( _fieldName, _content, _fileName, _mimeType ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BestHTTP.Forms.HTTPFormBase.AddBinaryData!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddField(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.Forms.HTTPFormBase gen_to_be_invoked = (BestHTTP.Forms.HTTPFormBase)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 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 _fieldName = LuaAPI.lua_tostring(L, 2); + string _value = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.AddField( _fieldName, _value ); + + + + return 0; + } + if(gen_param_count == 4&& (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)&& translator.Assignable(L, 4)) + { + string _fieldName = LuaAPI.lua_tostring(L, 2); + string _value = LuaAPI.lua_tostring(L, 3); + System.Text.Encoding _e = (System.Text.Encoding)translator.GetObject(L, 4, typeof(System.Text.Encoding)); + + gen_to_be_invoked.AddField( _fieldName, _value, _e ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BestHTTP.Forms.HTTPFormBase.AddField!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CopyFrom(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.Forms.HTTPFormBase gen_to_be_invoked = (BestHTTP.Forms.HTTPFormBase)translator.FastGetCSObj(L, 1); + + + + { + BestHTTP.Forms.HTTPFormBase _fields = (BestHTTP.Forms.HTTPFormBase)translator.GetObject(L, 2, typeof(BestHTTP.Forms.HTTPFormBase)); + + gen_to_be_invoked.CopyFrom( _fields ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PrepareRequest(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.Forms.HTTPFormBase gen_to_be_invoked = (BestHTTP.Forms.HTTPFormBase)translator.FastGetCSObj(L, 1); + + + + { + BestHTTP.HTTPRequest _request = (BestHTTP.HTTPRequest)translator.GetObject(L, 2, typeof(BestHTTP.HTTPRequest)); + + gen_to_be_invoked.PrepareRequest( _request ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.Forms.HTTPFormBase gen_to_be_invoked = (BestHTTP.Forms.HTTPFormBase)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetData( ); + 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_Fields(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.Forms.HTTPFormBase gen_to_be_invoked = (BestHTTP.Forms.HTTPFormBase)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Fields); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsEmpty(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.Forms.HTTPFormBase gen_to_be_invoked = (BestHTTP.Forms.HTTPFormBase)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsEmpty); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.Forms.HTTPFormBase gen_to_be_invoked = (BestHTTP.Forms.HTTPFormBase)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsChanged); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_HasBinary(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.Forms.HTTPFormBase gen_to_be_invoked = (BestHTTP.Forms.HTTPFormBase)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.HasBinary); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_HasLongValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.Forms.HTTPFormBase gen_to_be_invoked = (BestHTTP.Forms.HTTPFormBase)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.HasLongValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Fields(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.Forms.HTTPFormBase gen_to_be_invoked = (BestHTTP.Forms.HTTPFormBase)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Fields = (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/BestHTTP_Forms_HTTPUrlEncodedFormWrap.cs b/Assets/XLua/Gen/BestHTTP_Forms_HTTPUrlEncodedFormWrap.cs new file mode 100644 index 000000000..4567ad29c --- /dev/null +++ b/Assets/XLua/Gen/BestHTTP_Forms_HTTPUrlEncodedFormWrap.cs @@ -0,0 +1,168 @@ +#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 BestHTTPFormsHTTPUrlEncodedFormWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BestHTTP.Forms.HTTPUrlEncodedForm); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PrepareRequest", _m_PrepareRequest); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetData", _m_GetData); + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "EscapeString", _m_EscapeString_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 BestHTTP.Forms.HTTPUrlEncodedForm(); + 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 BestHTTP.Forms.HTTPUrlEncodedForm constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PrepareRequest(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.Forms.HTTPUrlEncodedForm gen_to_be_invoked = (BestHTTP.Forms.HTTPUrlEncodedForm)translator.FastGetCSObj(L, 1); + + + + { + BestHTTP.HTTPRequest _request = (BestHTTP.HTTPRequest)translator.GetObject(L, 2, typeof(BestHTTP.HTTPRequest)); + + gen_to_be_invoked.PrepareRequest( _request ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.Forms.HTTPUrlEncodedForm gen_to_be_invoked = (BestHTTP.Forms.HTTPUrlEncodedForm)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetData( ); + 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 _m_EscapeString_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _originalString = LuaAPI.lua_tostring(L, 1); + + var gen_ret = BestHTTP.Forms.HTTPUrlEncodedForm.EscapeString( _originalString ); + 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/BestHTTP_HTTPRequestWrap.cs b/Assets/XLua/Gen/BestHTTP_HTTPRequestWrap.cs new file mode 100644 index 000000000..f7a5ae1d4 --- /dev/null +++ b/Assets/XLua/Gen/BestHTTP_HTTPRequestWrap.cs @@ -0,0 +1,2341 @@ +#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 BestHTTPHTTPRequestWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BestHTTP.HTTPRequest); + Utils.BeginObjectRegister(type, L, translator, 0, 25, 52, 34); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddField", _m_AddField); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddBinaryData", _m_AddBinaryData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetForm", _m_SetForm); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetFormFields", _m_GetFormFields); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearForm", _m_ClearForm); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddHeader", _m_AddHeader); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetHeader", _m_SetHeader); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveHeader", _m_RemoveHeader); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasHeader", _m_HasHeader); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetFirstHeaderValue", _m_GetFirstHeaderValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHeaderValues", _m_GetHeaderValues); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveHeaders", _m_RemoveHeaders); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRangeHeader", _m_SetRangeHeader); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "EnumerateHeaders", _m_EnumerateHeaders); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DumpHeaders", _m_DumpHeaders); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetEntityBody", _m_GetEntityBody); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Send", _m_Send); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Abort", _m_Abort); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "MoveNext", _m_MoveNext); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Reset", _m_Reset); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Dispose", _m_Dispose); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CustomCertificationValidator", _e_CustomCertificationValidator); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBeforeRedirection", _e_OnBeforeRedirection); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBeforeHeaderSend", _e_OnBeforeHeaderSend); + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Uri", _g_get_Uri); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "MethodType", _g_get_MethodType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "RawData", _g_get_RawData); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "UploadStream", _g_get_UploadStream); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "DisposeUploadStream", _g_get_DisposeUploadStream); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "UseUploadStreamLength", _g_get_UseUploadStreamLength); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsKeepAlive", _g_get_IsKeepAlive); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "DisableCache", _g_get_DisableCache); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "CacheOnly", _g_get_CacheOnly); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "StreamFragmentSize", _g_get_StreamFragmentSize); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "StreamChunksImmediately", _g_get_StreamChunksImmediately); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ReadBufferSizeOverride", _g_get_ReadBufferSizeOverride); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "MaxFragmentQueueLength", _g_get_MaxFragmentQueueLength); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Callback", _g_get_Callback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "QueuedAt", _g_get_QueuedAt); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsConnectTimedOut", _g_get_IsConnectTimedOut); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ProcessingStarted", _g_get_ProcessingStarted); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsTimedOut", _g_get_IsTimedOut); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Retries", _g_get_Retries); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "MaxRetries", _g_get_MaxRetries); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsCancellationRequested", _g_get_IsCancellationRequested); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsRedirected", _g_get_IsRedirected); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "RedirectUri", _g_get_RedirectUri); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "CurrentUri", _g_get_CurrentUri); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Response", _g_get_Response); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ProxyResponse", _g_get_ProxyResponse); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Exception", _g_get_Exception); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Tag", _g_get_Tag); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Credentials", _g_get_Credentials); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "HasProxy", _g_get_HasProxy); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Proxy", _g_get_Proxy); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "MaxRedirects", _g_get_MaxRedirects); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "UseAlternateSSL", _g_get_UseAlternateSSL); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsCookiesEnabled", _g_get_IsCookiesEnabled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Cookies", _g_get_Cookies); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "FormUsage", _g_get_FormUsage); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "State", _g_get_State); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "RedirectCount", _g_get_RedirectCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ConnectTimeout", _g_get_ConnectTimeout); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Timeout", _g_get_Timeout); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "EnableTimoutForStreaming", _g_get_EnableTimoutForStreaming); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "EnableSafeReadOnUnknownContentLength", _g_get_EnableSafeReadOnUnknownContentLength); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "CustomCertificateVerifyer", _g_get_CustomCertificateVerifyer); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "CustomClientCredentialsProvider", _g_get_CustomClientCredentialsProvider); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "CustomTLSServerNameList", _g_get_CustomTLSServerNameList); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Context", _g_get_Context); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Timing", _g_get_Timing); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Current", _g_get_Current); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "OnUploadProgress", _g_get_OnUploadProgress); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "OnStreamingData", _g_get_OnStreamingData); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "OnHeadersReceived", _g_get_OnHeadersReceived); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "OnDownloadProgress", _g_get_OnDownloadProgress); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Uri", _s_set_Uri); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "MethodType", _s_set_MethodType); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "RawData", _s_set_RawData); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "UploadStream", _s_set_UploadStream); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "DisposeUploadStream", _s_set_DisposeUploadStream); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "UseUploadStreamLength", _s_set_UseUploadStreamLength); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "IsKeepAlive", _s_set_IsKeepAlive); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "DisableCache", _s_set_DisableCache); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "CacheOnly", _s_set_CacheOnly); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "StreamFragmentSize", _s_set_StreamFragmentSize); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "StreamChunksImmediately", _s_set_StreamChunksImmediately); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ReadBufferSizeOverride", _s_set_ReadBufferSizeOverride); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "MaxFragmentQueueLength", _s_set_MaxFragmentQueueLength); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Callback", _s_set_Callback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "MaxRetries", _s_set_MaxRetries); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Tag", _s_set_Tag); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Credentials", _s_set_Credentials); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Proxy", _s_set_Proxy); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "MaxRedirects", _s_set_MaxRedirects); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "UseAlternateSSL", _s_set_UseAlternateSSL); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "IsCookiesEnabled", _s_set_IsCookiesEnabled); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Cookies", _s_set_Cookies); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "FormUsage", _s_set_FormUsage); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ConnectTimeout", _s_set_ConnectTimeout); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Timeout", _s_set_Timeout); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "EnableTimoutForStreaming", _s_set_EnableTimoutForStreaming); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "EnableSafeReadOnUnknownContentLength", _s_set_EnableSafeReadOnUnknownContentLength); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "CustomCertificateVerifyer", _s_set_CustomCertificateVerifyer); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "CustomClientCredentialsProvider", _s_set_CustomClientCredentialsProvider); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "CustomTLSServerNameList", _s_set_CustomTLSServerNameList); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "OnUploadProgress", _s_set_OnUploadProgress); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "OnStreamingData", _s_set_OnStreamingData); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "OnHeadersReceived", _s_set_OnHeadersReceived); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "OnDownloadProgress", _s_set_OnDownloadProgress); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 3, 1, 1); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EOL", BestHTTP.HTTPRequest.EOL); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MethodNames", BestHTTP.HTTPRequest.MethodNames); + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "UploadChunkSize", _g_get_UploadChunkSize); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "UploadChunkSize", _s_set_UploadChunkSize); + + + 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) == 2 && translator.Assignable(L, 2)) + { + System.Uri _uri = (System.Uri)translator.GetObject(L, 2, typeof(System.Uri)); + + var gen_ret = new BestHTTP.HTTPRequest(_uri); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 3 && translator.Assignable(L, 2) && translator.Assignable(L, 3)) + { + System.Uri _uri = (System.Uri)translator.GetObject(L, 2, typeof(System.Uri)); + BestHTTP.OnRequestFinishedDelegate _callback = translator.GetDelegate(L, 3); + + var gen_ret = new BestHTTP.HTTPRequest(_uri, _callback); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 4 && translator.Assignable(L, 2) && LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3) && translator.Assignable(L, 4)) + { + System.Uri _uri = (System.Uri)translator.GetObject(L, 2, typeof(System.Uri)); + bool _isKeepAlive = LuaAPI.lua_toboolean(L, 3); + BestHTTP.OnRequestFinishedDelegate _callback = translator.GetDelegate(L, 4); + + var gen_ret = new BestHTTP.HTTPRequest(_uri, _isKeepAlive, _callback); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 5 && translator.Assignable(L, 2) && LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4) && translator.Assignable(L, 5)) + { + System.Uri _uri = (System.Uri)translator.GetObject(L, 2, typeof(System.Uri)); + bool _isKeepAlive = LuaAPI.lua_toboolean(L, 3); + bool _disableCache = LuaAPI.lua_toboolean(L, 4); + BestHTTP.OnRequestFinishedDelegate _callback = translator.GetDelegate(L, 5); + + var gen_ret = new BestHTTP.HTTPRequest(_uri, _isKeepAlive, _disableCache, _callback); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 3 && translator.Assignable(L, 2) && translator.Assignable(L, 3)) + { + System.Uri _uri = (System.Uri)translator.GetObject(L, 2, typeof(System.Uri)); + BestHTTP.HTTPMethods _methodType;translator.Get(L, 3, out _methodType); + + var gen_ret = new BestHTTP.HTTPRequest(_uri, _methodType); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 4 && translator.Assignable(L, 2) && translator.Assignable(L, 3) && translator.Assignable(L, 4)) + { + System.Uri _uri = (System.Uri)translator.GetObject(L, 2, typeof(System.Uri)); + BestHTTP.HTTPMethods _methodType;translator.Get(L, 3, out _methodType); + BestHTTP.OnRequestFinishedDelegate _callback = translator.GetDelegate(L, 4); + + var gen_ret = new BestHTTP.HTTPRequest(_uri, _methodType, _callback); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 5 && translator.Assignable(L, 2) && translator.Assignable(L, 3) && LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4) && translator.Assignable(L, 5)) + { + System.Uri _uri = (System.Uri)translator.GetObject(L, 2, typeof(System.Uri)); + BestHTTP.HTTPMethods _methodType;translator.Get(L, 3, out _methodType); + bool _isKeepAlive = LuaAPI.lua_toboolean(L, 4); + BestHTTP.OnRequestFinishedDelegate _callback = translator.GetDelegate(L, 5); + + var gen_ret = new BestHTTP.HTTPRequest(_uri, _methodType, _isKeepAlive, _callback); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 6 && translator.Assignable(L, 2) && translator.Assignable(L, 3) && LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4) && LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5) && translator.Assignable(L, 6)) + { + System.Uri _uri = (System.Uri)translator.GetObject(L, 2, typeof(System.Uri)); + BestHTTP.HTTPMethods _methodType;translator.Get(L, 3, out _methodType); + bool _isKeepAlive = LuaAPI.lua_toboolean(L, 4); + bool _disableCache = LuaAPI.lua_toboolean(L, 5); + BestHTTP.OnRequestFinishedDelegate _callback = translator.GetDelegate(L, 6); + + var gen_ret = new BestHTTP.HTTPRequest(_uri, _methodType, _isKeepAlive, _disableCache, _callback); + 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 BestHTTP.HTTPRequest constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddField(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 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 _fieldName = LuaAPI.lua_tostring(L, 2); + string _value = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.AddField( _fieldName, _value ); + + + + return 0; + } + if(gen_param_count == 4&& (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)&& translator.Assignable(L, 4)) + { + string _fieldName = LuaAPI.lua_tostring(L, 2); + string _value = LuaAPI.lua_tostring(L, 3); + System.Text.Encoding _e = (System.Text.Encoding)translator.GetObject(L, 4, typeof(System.Text.Encoding)); + + gen_to_be_invoked.AddField( _fieldName, _value, _e ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BestHTTP.HTTPRequest.AddField!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddBinaryData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 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 _fieldName = LuaAPI.lua_tostring(L, 2); + byte[] _content = LuaAPI.lua_tobytes(L, 3); + + gen_to_be_invoked.AddBinaryData( _fieldName, _content ); + + + + return 0; + } + if(gen_param_count == 4&& (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)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)) + { + string _fieldName = LuaAPI.lua_tostring(L, 2); + byte[] _content = LuaAPI.lua_tobytes(L, 3); + string _fileName = LuaAPI.lua_tostring(L, 4); + + gen_to_be_invoked.AddBinaryData( _fieldName, _content, _fileName ); + + + + return 0; + } + if(gen_param_count == 5&& (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)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 5) || LuaAPI.lua_type(L, 5) == LuaTypes.LUA_TSTRING)) + { + string _fieldName = LuaAPI.lua_tostring(L, 2); + byte[] _content = LuaAPI.lua_tobytes(L, 3); + string _fileName = LuaAPI.lua_tostring(L, 4); + string _mimeType = LuaAPI.lua_tostring(L, 5); + + gen_to_be_invoked.AddBinaryData( _fieldName, _content, _fileName, _mimeType ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BestHTTP.HTTPRequest.AddBinaryData!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetForm(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + + + + { + BestHTTP.Forms.HTTPFormBase _form = (BestHTTP.Forms.HTTPFormBase)translator.GetObject(L, 2, typeof(BestHTTP.Forms.HTTPFormBase)); + + gen_to_be_invoked.SetForm( _form ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetFormFields(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetFormFields( ); + 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_ClearForm(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearForm( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddHeader(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + string _value = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.AddHeader( _name, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetHeader(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + string _value = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.SetHeader( _name, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveHeader(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.RemoveHeader( _name ); + 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_HasHeader(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.HasHeader( _name ); + 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_GetFirstHeaderValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetFirstHeaderValue( _name ); + 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 _m_GetHeaderValues(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetHeaderValues( _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_RemoveHeaders(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RemoveHeaders( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRangeHeader(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) || LuaAPI.lua_isint64(L, 2))) + { + long _firstBytePos = LuaAPI.lua_toint64(L, 2); + + gen_to_be_invoked.SetRangeHeader( _firstBytePos ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) || LuaAPI.lua_isint64(L, 2))&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) || LuaAPI.lua_isint64(L, 3))) + { + long _firstBytePos = LuaAPI.lua_toint64(L, 2); + long _lastBytePos = LuaAPI.lua_toint64(L, 3); + + gen_to_be_invoked.SetRangeHeader( _firstBytePos, _lastBytePos ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BestHTTP.HTTPRequest.SetRangeHeader!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_EnumerateHeaders(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + BestHTTP.OnHeaderEnumerationDelegate _callback = translator.GetDelegate(L, 2); + + gen_to_be_invoked.EnumerateHeaders( _callback ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + BestHTTP.OnHeaderEnumerationDelegate _callback = translator.GetDelegate(L, 2); + bool _callBeforeSendCallback = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.EnumerateHeaders( _callback, _callBeforeSendCallback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to BestHTTP.HTTPRequest.EnumerateHeaders!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DumpHeaders(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.DumpHeaders( ); + 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 _m_GetEntityBody(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetEntityBody( ); + 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 _m_Send(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Send( ); + 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_Abort(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Abort( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Clear(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Clear( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_MoveNext(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.MoveNext( ); + 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_Reset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Reset( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Dispose(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Dispose( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Uri(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Uri); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_MethodType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.MethodType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_RawData(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.RawData); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UploadStream(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.UploadStream); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DisposeUploadStream(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.DisposeUploadStream); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UseUploadStreamLength(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.UseUploadStreamLength); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsKeepAlive(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsKeepAlive); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DisableCache(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.DisableCache); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_CacheOnly(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.CacheOnly); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_StreamFragmentSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.StreamFragmentSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_StreamChunksImmediately(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.StreamChunksImmediately); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ReadBufferSizeOverride(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.ReadBufferSizeOverride); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_MaxFragmentQueueLength(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.MaxFragmentQueueLength); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Callback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Callback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_QueuedAt(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.QueuedAt); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsConnectTimedOut(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsConnectTimedOut); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ProcessingStarted(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.ProcessingStarted); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsTimedOut(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsTimedOut); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Retries(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Retries); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_MaxRetries(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.MaxRetries); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsCancellationRequested(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsCancellationRequested); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsRedirected(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsRedirected); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_RedirectUri(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.RedirectUri); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_CurrentUri(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.CurrentUri); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Response(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Response); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ProxyResponse(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.ProxyResponse); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Exception(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Exception); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Tag(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.Tag); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Credentials(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Credentials); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_HasProxy(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.HasProxy); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Proxy(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Proxy); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_MaxRedirects(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.MaxRedirects); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UseAlternateSSL(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.UseAlternateSSL); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsCookiesEnabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsCookiesEnabled); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Cookies(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Cookies); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_FormUsage(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.FormUsage); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_State(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.State); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_RedirectCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.RedirectCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ConnectTimeout(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.ConnectTimeout); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Timeout(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Timeout); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_EnableTimoutForStreaming(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.EnableTimoutForStreaming); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_EnableSafeReadOnUnknownContentLength(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.EnableSafeReadOnUnknownContentLength); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_CustomCertificateVerifyer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.CustomCertificateVerifyer); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_CustomClientCredentialsProvider(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.CustomClientCredentialsProvider); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_CustomTLSServerNameList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.CustomTLSServerNameList); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Context(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Context); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Timing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Timing); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Current(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.Current); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UploadChunkSize(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, BestHTTP.HTTPRequest.UploadChunkSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_OnUploadProgress(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.OnUploadProgress); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_OnStreamingData(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.OnStreamingData); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_OnHeadersReceived(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.OnHeadersReceived); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_OnDownloadProgress(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.OnDownloadProgress); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Uri(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Uri = (System.Uri)translator.GetObject(L, 2, typeof(System.Uri)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_MethodType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + BestHTTP.HTTPMethods gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.MethodType = 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_RawData(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.RawData = LuaAPI.lua_tobytes(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_UploadStream(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.UploadStream = (System.IO.Stream)translator.GetObject(L, 2, typeof(System.IO.Stream)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_DisposeUploadStream(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.DisposeUploadStream = 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_UseUploadStreamLength(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.UseUploadStreamLength = 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_IsKeepAlive(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.IsKeepAlive = 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_DisableCache(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.DisableCache = 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_CacheOnly(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.CacheOnly = 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_StreamFragmentSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.StreamFragmentSize = 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_StreamChunksImmediately(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.StreamChunksImmediately = 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_ReadBufferSizeOverride(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ReadBufferSizeOverride = 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_MaxFragmentQueueLength(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.MaxFragmentQueueLength = 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_Callback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Callback = translator.GetDelegate(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_MaxRetries(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.MaxRetries = 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_Tag(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Tag = translator.GetObject(L, 2, typeof(object)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Credentials(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Credentials = (BestHTTP.Authentication.Credentials)translator.GetObject(L, 2, typeof(BestHTTP.Authentication.Credentials)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Proxy(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Proxy = (BestHTTP.Proxy)translator.GetObject(L, 2, typeof(BestHTTP.Proxy)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_MaxRedirects(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.MaxRedirects = 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_UseAlternateSSL(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.UseAlternateSSL = 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_IsCookiesEnabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.IsCookiesEnabled = 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_Cookies(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Cookies = (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; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_FormUsage(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + BestHTTP.Forms.HTTPFormUsage gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.FormUsage = 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_ConnectTimeout(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + System.TimeSpan gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.ConnectTimeout = 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_Timeout(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + System.TimeSpan gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.Timeout = 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_EnableTimoutForStreaming(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.EnableTimoutForStreaming = 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_EnableSafeReadOnUnknownContentLength(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.EnableSafeReadOnUnknownContentLength = 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_CustomCertificateVerifyer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.CustomCertificateVerifyer = (BestHTTP.SecureProtocol.Org.BouncyCastle.Crypto.Tls.ICertificateVerifyer)translator.GetObject(L, 2, typeof(BestHTTP.SecureProtocol.Org.BouncyCastle.Crypto.Tls.ICertificateVerifyer)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_CustomClientCredentialsProvider(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.CustomClientCredentialsProvider = (BestHTTP.SecureProtocol.Org.BouncyCastle.Crypto.Tls.IClientCredentialsProvider)translator.GetObject(L, 2, typeof(BestHTTP.SecureProtocol.Org.BouncyCastle.Crypto.Tls.IClientCredentialsProvider)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_CustomTLSServerNameList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.CustomTLSServerNameList = (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; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_UploadChunkSize(RealStatePtr L) + { + try { + + BestHTTP.HTTPRequest.UploadChunkSize = LuaAPI.xlua_tointeger(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_OnUploadProgress(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.OnUploadProgress = translator.GetDelegate(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_OnStreamingData(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.OnStreamingData = translator.GetDelegate(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_OnHeadersReceived(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.OnHeadersReceived = translator.GetDelegate>(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_OnDownloadProgress(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.OnDownloadProgress = translator.GetDelegate(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_CustomCertificationValidator(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + System.Func gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Func!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.CustomCertificationValidator += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.CustomCertificationValidator -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to BestHTTP.HTTPRequest.CustomCertificationValidator!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnBeforeRedirection(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + BestHTTP.OnBeforeRedirectionDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need BestHTTP.OnBeforeRedirectionDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnBeforeRedirection += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnBeforeRedirection -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to BestHTTP.HTTPRequest.OnBeforeRedirection!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnBeforeHeaderSend(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + BestHTTP.HTTPRequest gen_to_be_invoked = (BestHTTP.HTTPRequest)translator.FastGetCSObj(L, 1); + BestHTTP.OnBeforeHeaderSendDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need BestHTTP.OnBeforeHeaderSendDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnBeforeHeaderSend += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnBeforeHeaderSend -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to BestHTTP.HTTPRequest.OnBeforeHeaderSend!"); + return 0; + } + + + + } +} diff --git a/Assets/XLua/Gen/BestHTTP_HTTPResponseWrap.cs b/Assets/XLua/Gen/BestHTTP_HTTPResponseWrap.cs new file mode 100644 index 000000000..d8ca48eeb --- /dev/null +++ b/Assets/XLua/Gen/BestHTTP_HTTPResponseWrap.cs @@ -0,0 +1,675 @@ +#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 BestHTTPHTTPResponseWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(BestHTTP.HTTPResponse); + Utils.BeginObjectRegister(type, L, translator, 0, 8, 18, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Receive", _m_Receive); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddHeader", _m_AddHeader); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHeaderValues", _m_GetHeaderValues); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetFirstHeaderValue", _m_GetFirstHeaderValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasHeaderWithValue", _m_HasHeaderWithValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasHeader", _m_HasHeader); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetRange", _m_GetRange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Dispose", _m_Dispose); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "VersionMajor", _g_get_VersionMajor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "VersionMinor", _g_get_VersionMinor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "StatusCode", _g_get_StatusCode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsSuccess", _g_get_IsSuccess); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Message", _g_get_Message); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsStreamed", _g_get_IsStreamed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsFromCache", _g_get_IsFromCache); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "CacheFileInfo", _g_get_CacheFileInfo); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsCacheOnly", _g_get_IsCacheOnly); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsProxyResponse", _g_get_IsProxyResponse); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Headers", _g_get_Headers); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Data", _g_get_Data); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsUpgraded", _g_get_IsUpgraded); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Cookies", _g_get_Cookies); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "DataAsText", _g_get_DataAsText); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "DataAsTexture2D", _g_get_DataAsTexture2D); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsClosedManually", _g_get_IsClosedManually); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Context", _g_get_Context); + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 1, 1); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "MinReadBufferSize", _g_get_MinReadBufferSize); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "MinReadBufferSize", _s_set_MinReadBufferSize); + + + 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) == 6 && translator.Assignable(L, 2) && translator.Assignable(L, 3) && LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4) && LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5) && LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)) + { + BestHTTP.HTTPRequest _request = (BestHTTP.HTTPRequest)translator.GetObject(L, 2, typeof(BestHTTP.HTTPRequest)); + System.IO.Stream _stream = (System.IO.Stream)translator.GetObject(L, 3, typeof(System.IO.Stream)); + bool _isStreamed = LuaAPI.lua_toboolean(L, 4); + bool _isFromCache = LuaAPI.lua_toboolean(L, 5); + bool _isProxyResponse = LuaAPI.lua_toboolean(L, 6); + + var gen_ret = new BestHTTP.HTTPResponse(_request, _stream, _isStreamed, _isFromCache, _isProxyResponse); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 5 && translator.Assignable(L, 2) && translator.Assignable(L, 3) && LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4) && LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)) + { + BestHTTP.HTTPRequest _request = (BestHTTP.HTTPRequest)translator.GetObject(L, 2, typeof(BestHTTP.HTTPRequest)); + System.IO.Stream _stream = (System.IO.Stream)translator.GetObject(L, 3, typeof(System.IO.Stream)); + bool _isStreamed = LuaAPI.lua_toboolean(L, 4); + bool _isFromCache = LuaAPI.lua_toboolean(L, 5); + + var gen_ret = new BestHTTP.HTTPResponse(_request, _stream, _isStreamed, _isFromCache); + 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 BestHTTP.HTTPResponse constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Receive(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPResponse gen_to_be_invoked = (BestHTTP.HTTPResponse)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + int _forceReadRawContentLength = LuaAPI.xlua_tointeger(L, 2); + bool _readPayloadData = LuaAPI.lua_toboolean(L, 3); + bool _sendUpgradedEvent = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.Receive( _forceReadRawContentLength, _readPayloadData, _sendUpgradedEvent ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + int _forceReadRawContentLength = LuaAPI.xlua_tointeger(L, 2); + bool _readPayloadData = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.Receive( _forceReadRawContentLength, _readPayloadData ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _forceReadRawContentLength = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.Receive( _forceReadRawContentLength ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.Receive( ); + LuaAPI.lua_pushboolean(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 BestHTTP.HTTPResponse.Receive!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddHeader(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPResponse gen_to_be_invoked = (BestHTTP.HTTPResponse)translator.FastGetCSObj(L, 1); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + string _value = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.AddHeader( _name, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetHeaderValues(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPResponse gen_to_be_invoked = (BestHTTP.HTTPResponse)translator.FastGetCSObj(L, 1); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetHeaderValues( _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_GetFirstHeaderValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPResponse gen_to_be_invoked = (BestHTTP.HTTPResponse)translator.FastGetCSObj(L, 1); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetFirstHeaderValue( _name ); + 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 _m_HasHeaderWithValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPResponse gen_to_be_invoked = (BestHTTP.HTTPResponse)translator.FastGetCSObj(L, 1); + + + + { + string _headerName = LuaAPI.lua_tostring(L, 2); + string _value = LuaAPI.lua_tostring(L, 3); + + var gen_ret = gen_to_be_invoked.HasHeaderWithValue( _headerName, _value ); + 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_HasHeader(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPResponse gen_to_be_invoked = (BestHTTP.HTTPResponse)translator.FastGetCSObj(L, 1); + + + + { + string _headerName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.HasHeader( _headerName ); + 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_GetRange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPResponse gen_to_be_invoked = (BestHTTP.HTTPResponse)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetRange( ); + 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_Dispose(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + BestHTTP.HTTPResponse gen_to_be_invoked = (BestHTTP.HTTPResponse)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Dispose( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_VersionMajor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPResponse gen_to_be_invoked = (BestHTTP.HTTPResponse)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.VersionMajor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_VersionMinor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPResponse gen_to_be_invoked = (BestHTTP.HTTPResponse)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.VersionMinor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_StatusCode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPResponse gen_to_be_invoked = (BestHTTP.HTTPResponse)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.StatusCode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsSuccess(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPResponse gen_to_be_invoked = (BestHTTP.HTTPResponse)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsSuccess); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Message(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPResponse gen_to_be_invoked = (BestHTTP.HTTPResponse)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Message); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsStreamed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPResponse gen_to_be_invoked = (BestHTTP.HTTPResponse)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsStreamed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsFromCache(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPResponse gen_to_be_invoked = (BestHTTP.HTTPResponse)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsFromCache); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_CacheFileInfo(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPResponse gen_to_be_invoked = (BestHTTP.HTTPResponse)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.CacheFileInfo); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsCacheOnly(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPResponse gen_to_be_invoked = (BestHTTP.HTTPResponse)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsCacheOnly); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsProxyResponse(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPResponse gen_to_be_invoked = (BestHTTP.HTTPResponse)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsProxyResponse); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Headers(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPResponse gen_to_be_invoked = (BestHTTP.HTTPResponse)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Headers); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Data(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPResponse gen_to_be_invoked = (BestHTTP.HTTPResponse)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Data); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsUpgraded(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPResponse gen_to_be_invoked = (BestHTTP.HTTPResponse)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsUpgraded); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Cookies(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPResponse gen_to_be_invoked = (BestHTTP.HTTPResponse)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Cookies); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DataAsText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPResponse gen_to_be_invoked = (BestHTTP.HTTPResponse)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.DataAsText); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DataAsTexture2D(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPResponse gen_to_be_invoked = (BestHTTP.HTTPResponse)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.DataAsTexture2D); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsClosedManually(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPResponse gen_to_be_invoked = (BestHTTP.HTTPResponse)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsClosedManually); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Context(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + BestHTTP.HTTPResponse gen_to_be_invoked = (BestHTTP.HTTPResponse)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Context); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_MinReadBufferSize(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, BestHTTP.HTTPResponse.MinReadBufferSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_MinReadBufferSize(RealStatePtr L) + { + try { + + BestHTTP.HTTPResponse.MinReadBufferSize = LuaAPI.xlua_tointeger(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/CameraAdjustWrap.cs b/Assets/XLua/Gen/CameraAdjustWrap.cs new file mode 100644 index 000000000..14e60a086 --- /dev/null +++ b/Assets/XLua/Gen/CameraAdjustWrap.cs @@ -0,0 +1,146 @@ +#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 CameraAdjustWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(CameraAdjust); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 2); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "logicalScreenWidth", _g_get_logicalScreenWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "logicalScreenHeight", _g_get_logicalScreenHeight); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "logicalScreenWidth", _s_set_logicalScreenWidth); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "logicalScreenHeight", _s_set_logicalScreenHeight); + + + 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 CameraAdjust(); + 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 CameraAdjust constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_logicalScreenWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + CameraAdjust gen_to_be_invoked = (CameraAdjust)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.logicalScreenWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_logicalScreenHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + CameraAdjust gen_to_be_invoked = (CameraAdjust)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.logicalScreenHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_logicalScreenWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + CameraAdjust gen_to_be_invoked = (CameraAdjust)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.logicalScreenWidth = 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_logicalScreenHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + CameraAdjust gen_to_be_invoked = (CameraAdjust)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.logicalScreenHeight = 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/CloudControlWrap.cs b/Assets/XLua/Gen/CloudControlWrap.cs new file mode 100644 index 000000000..8fd22077f --- /dev/null +++ b/Assets/XLua/Gen/CloudControlWrap.cs @@ -0,0 +1,239 @@ +#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 CloudControlWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(CloudControl); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 4, 4); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnEnable", _m_OnEnable); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "_CloudMap", _g_get__CloudMap); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "_CloudColor", _g_get__CloudColor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "_Size", _g_get__Size); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "_Speed", _g_get__Speed); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "_CloudMap", _s_set__CloudMap); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "_CloudColor", _s_set__CloudColor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "_Size", _s_set__Size); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "_Speed", _s_set__Speed); + + + 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 CloudControl(); + 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 CloudControl constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnEnable(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + CloudControl gen_to_be_invoked = (CloudControl)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.OnEnable( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get__CloudMap(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + CloudControl gen_to_be_invoked = (CloudControl)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked._CloudMap); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get__CloudColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + CloudControl gen_to_be_invoked = (CloudControl)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineColor(L, gen_to_be_invoked._CloudColor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get__Size(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + CloudControl gen_to_be_invoked = (CloudControl)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked._Size); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get__Speed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + CloudControl gen_to_be_invoked = (CloudControl)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked._Speed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set__CloudMap(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + CloudControl gen_to_be_invoked = (CloudControl)translator.FastGetCSObj(L, 1); + gen_to_be_invoked._CloudMap = (UnityEngine.Texture)translator.GetObject(L, 2, typeof(UnityEngine.Texture)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set__CloudColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + CloudControl gen_to_be_invoked = (CloudControl)translator.FastGetCSObj(L, 1); + UnityEngine.Color gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked._CloudColor = 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__Size(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + CloudControl gen_to_be_invoked = (CloudControl)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked._Size = 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__Speed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + CloudControl gen_to_be_invoked = (CloudControl)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked._Speed = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/DG_Tweening_Core_ABSSequentiableWrap.cs b/Assets/XLua/Gen/DG_Tweening_Core_ABSSequentiableWrap.cs new file mode 100644 index 000000000..cac5056fc --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_Core_ABSSequentiableWrap.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 DGTweeningCoreABSSequentiableWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.Core.ABSSequentiable); + 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, "DG.Tweening.Core.ABSSequentiable does not have a constructor!"); + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/DG_Tweening_Core_DOTweenComponentWrap.cs b/Assets/XLua/Gen/DG_Tweening_Core_DOTweenComponentWrap.cs new file mode 100644 index 000000000..3a69e5c62 --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_Core_DOTweenComponentWrap.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 DGTweeningCoreDOTweenComponentWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.Core.DOTweenComponent); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 1, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnApplicationPause", _m_OnApplicationPause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetCapacity", _m_SetCapacity); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "inspectorUpdater", _g_get_inspectorUpdater); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "inspectorUpdater", _s_set_inspectorUpdater); + + + 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 DG.Tweening.Core.DOTweenComponent(); + 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 DG.Tweening.Core.DOTweenComponent constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnApplicationPause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.DOTweenComponent gen_to_be_invoked = (DG.Tweening.Core.DOTweenComponent)translator.FastGetCSObj(L, 1); + + + + { + bool _pauseStatus = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.OnApplicationPause( _pauseStatus ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetCapacity(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.DOTweenComponent gen_to_be_invoked = (DG.Tweening.Core.DOTweenComponent)translator.FastGetCSObj(L, 1); + + + + { + int _tweenersCapacity = LuaAPI.xlua_tointeger(L, 2); + int _sequencesCapacity = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.SetCapacity( _tweenersCapacity, _sequencesCapacity ); + 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 _g_get_inspectorUpdater(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.DOTweenComponent gen_to_be_invoked = (DG.Tweening.Core.DOTweenComponent)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.inspectorUpdater); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_inspectorUpdater(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.DOTweenComponent gen_to_be_invoked = (DG.Tweening.Core.DOTweenComponent)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.inspectorUpdater = 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/DG_Tweening_Core_TweenerCore_3_System_Single_System_Single_DG_Tweening_Plugins_Options_FloatOptions_Wrap.cs b/Assets/XLua/Gen/DG_Tweening_Core_TweenerCore_3_System_Single_System_Single_DG_Tweening_Plugins_Options_FloatOptions_Wrap.cs new file mode 100644 index 000000000..dfec0c335 --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_Core_TweenerCore_3_System_Single_System_Single_DG_Tweening_Plugins_Options_FloatOptions_Wrap.cs @@ -0,0 +1,1500 @@ +#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; +using DG.Tweening; + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class DGTweeningCoreTweenerCore_3_SystemSingleSystemSingleDGTweeningPluginsOptionsFloatOptions_Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.Core.TweenerCore); + Utils.BeginObjectRegister(type, L, translator, 0, 28, 6, 6); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ChangeStartValue", _m_ChangeStartValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ChangeEndValue", _m_ChangeEndValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ChangeValues", _m_ChangeValues); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Pause", _m_Pause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Play", _m_Play); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAutoKill", _m_SetAutoKill); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetId", _m_SetId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLink", _m_SetLink); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTarget", _m_SetTarget); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLoops", _m_SetLoops); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetEase", _m_SetEase); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRecyclable", _m_SetRecyclable); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetUpdate", _m_SetUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnStart", _m_OnStart); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPlay", _m_OnPlay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPause", _m_OnPause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRewind", _m_OnRewind); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnUpdate", _m_OnUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnStepComplete", _m_OnStepComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnComplete", _m_OnComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnKill", _m_OnKill); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnWaypointChange", _m_OnWaypointChange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAs", _m_SetAs); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "From", _m_From); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetDelay", _m_SetDelay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRelative", _m_SetRelative); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSpeedBased", _m_SetSpeedBased); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetOptions", _m_SetOptions); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startValue", _g_get_startValue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "endValue", _g_get_endValue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "changeValue", _g_get_changeValue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "plugOptions", _g_get_plugOptions); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "getter", _g_get_getter); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "setter", _g_get_setter); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startValue", _s_set_startValue); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "endValue", _s_set_endValue); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "changeValue", _s_set_changeValue); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "plugOptions", _s_set_plugOptions); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "getter", _s_set_getter); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "setter", _s_set_setter); + + + 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, "DG.Tweening.Core.TweenerCore does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ChangeStartValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _newStartValue = (float)LuaAPI.lua_tonumber(L, 2); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _newStartValue = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue ); + 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 DG.Tweening.Core.TweenerCore.ChangeStartValue!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ChangeEndValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + float _newEndValue = (float)LuaAPI.lua_tonumber(L, 2); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + float _newEndValue = (float)LuaAPI.lua_tonumber(L, 2); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _newEndValue = (float)LuaAPI.lua_tonumber(L, 2); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _newEndValue = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue ); + 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 DG.Tweening.Core.TweenerCore.ChangeEndValue!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ChangeValues(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _newStartValue = (float)LuaAPI.lua_tonumber(L, 2); + float _newEndValue = (float)LuaAPI.lua_tonumber(L, 3); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _newStartValue = (float)LuaAPI.lua_tonumber(L, 2); + float _newEndValue = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + object _newEndValue = translator.GetObject(L, 3, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + object _newEndValue = translator.GetObject(L, 3, typeof(object)); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue ); + 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 DG.Tweening.Core.TweenerCore.ChangeValues!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Pause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Pause( ); + 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_Play(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Play( ); + 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_SetAutoKill(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetAutoKill( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _autoKillOnCompletion = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetAutoKill( _autoKillOnCompletion ); + 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 DG.Tweening.Core.TweenerCore.SetAutoKill!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _intId = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.SetId( _intId ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _objectId = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.SetId( _objectId ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _stringId = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.SetId( _stringId ); + 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 DG.Tweening.Core.TweenerCore.SetId!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLink(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.GameObject _gameObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + var gen_ret = gen_to_be_invoked.SetLink( _gameObject ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.GameObject _gameObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + DG.Tweening.LinkBehaviour _behaviour;translator.Get(L, 3, out _behaviour); + + var gen_ret = gen_to_be_invoked.SetLink( _gameObject, _behaviour ); + 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 DG.Tweening.Core.TweenerCore.SetLink!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTarget(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + object _target = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.SetTarget( _target ); + 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_SetLoops(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _loops = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.SetLoops( _loops ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _loops = LuaAPI.xlua_tointeger(L, 2); + DG.Tweening.LoopType _loopType;translator.Get(L, 3, out _loopType); + + var gen_ret = gen_to_be_invoked.SetLoops( _loops, _loopType ); + 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 DG.Tweening.Core.TweenerCore.SetLoops!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetEase(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + + var gen_ret = gen_to_be_invoked.SetEase( _ease ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.AnimationCurve _animCurve = (UnityEngine.AnimationCurve)translator.GetObject(L, 2, typeof(UnityEngine.AnimationCurve)); + + var gen_ret = gen_to_be_invoked.SetEase( _animCurve ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.EaseFunction _customEase = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.SetEase( _customEase ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + float _overshoot = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.SetEase( _ease, _overshoot ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + float _amplitude = (float)LuaAPI.lua_tonumber(L, 3); + float _period = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.SetEase( _ease, _amplitude, _period ); + 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 DG.Tweening.Core.TweenerCore.SetEase!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRecyclable(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetRecyclable( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _recyclable = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetRecyclable( _recyclable ); + 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 DG.Tweening.Core.TweenerCore.SetRecyclable!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isIndependentUpdate = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetUpdate( _isIndependentUpdate ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.UpdateType _updateType;translator.Get(L, 2, out _updateType); + + var gen_ret = gen_to_be_invoked.SetUpdate( _updateType ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.UpdateType _updateType;translator.Get(L, 2, out _updateType); + bool _isIndependentUpdate = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.SetUpdate( _updateType, _isIndependentUpdate ); + 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 DG.Tweening.Core.TweenerCore.SetUpdate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnStart(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnStart( _action ); + 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_OnPlay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnPlay( _action ); + 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_OnPause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnPause( _action ); + 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_OnRewind(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnRewind( _action ); + 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_OnUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnUpdate( _action ); + 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_OnStepComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnStepComplete( _action ); + 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_OnComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnComplete( _action ); + 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_OnKill(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnKill( _action ); + 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_OnWaypointChange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.OnWaypointChange( _action ); + 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_SetAs(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.Tween _asTween = (DG.Tweening.Tween)translator.GetObject(L, 2, typeof(DG.Tweening.Tween)); + + var gen_ret = gen_to_be_invoked.SetAs( _asTween ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.TweenParams _tweenParams = (DG.Tweening.TweenParams)translator.GetObject(L, 2, typeof(DG.Tweening.TweenParams)); + + var gen_ret = gen_to_be_invoked.SetAs( _tweenParams ); + 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 DG.Tweening.Core.TweenerCore.SetAs!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_From(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.From( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isRelative = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.From( _isRelative ); + 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 DG.Tweening.Core.TweenerCore.From!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetDelay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _delay = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.SetDelay( _delay ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + float _delay = (float)LuaAPI.lua_tonumber(L, 2); + bool _asPrependedIntervalIfSequence = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.SetDelay( _delay, _asPrependedIntervalIfSequence ); + 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 DG.Tweening.Core.TweenerCore.SetDelay!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRelative(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetRelative( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isRelative = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetRelative( _isRelative ); + 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 DG.Tweening.Core.TweenerCore.SetRelative!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSpeedBased(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetSpeedBased( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isSpeedBased = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetSpeedBased( _isSpeedBased ); + 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 DG.Tweening.Core.TweenerCore.SetSpeedBased!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetOptions(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + bool _snapping = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetOptions( _snapping ); + 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_startValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.startValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_endValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.endValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_changeValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.changeValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_plugOptions(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.plugOptions); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_getter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.getter); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_setter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.setter); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.startValue = (float)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_endValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.endValue = (float)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_changeValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.changeValue = (float)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_plugOptions(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + DG.Tweening.Plugins.Options.FloatOptions gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.plugOptions = 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_getter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.getter = translator.GetDelegate>(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_setter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.setter = translator.GetDelegate>(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/DG_Tweening_Core_TweenerCore_3_UnityEngine_Color_UnityEngine_Color_DG_Tweening_Plugins_Options_ColorOptions_Wrap.cs b/Assets/XLua/Gen/DG_Tweening_Core_TweenerCore_3_UnityEngine_Color_UnityEngine_Color_DG_Tweening_Plugins_Options_ColorOptions_Wrap.cs new file mode 100644 index 000000000..4f29895cd --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_Core_TweenerCore_3_UnityEngine_Color_UnityEngine_Color_DG_Tweening_Plugins_Options_ColorOptions_Wrap.cs @@ -0,0 +1,1539 @@ +#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; +using DG.Tweening; + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class DGTweeningCoreTweenerCore_3_UnityEngineColorUnityEngineColorDGTweeningPluginsOptionsColorOptions_Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.Core.TweenerCore); + Utils.BeginObjectRegister(type, L, translator, 0, 28, 6, 6); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ChangeStartValue", _m_ChangeStartValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ChangeEndValue", _m_ChangeEndValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ChangeValues", _m_ChangeValues); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Pause", _m_Pause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Play", _m_Play); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAutoKill", _m_SetAutoKill); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetId", _m_SetId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLink", _m_SetLink); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTarget", _m_SetTarget); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLoops", _m_SetLoops); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetEase", _m_SetEase); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRecyclable", _m_SetRecyclable); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetUpdate", _m_SetUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnStart", _m_OnStart); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPlay", _m_OnPlay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPause", _m_OnPause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRewind", _m_OnRewind); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnUpdate", _m_OnUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnStepComplete", _m_OnStepComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnComplete", _m_OnComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnKill", _m_OnKill); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnWaypointChange", _m_OnWaypointChange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAs", _m_SetAs); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "From", _m_From); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetDelay", _m_SetDelay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRelative", _m_SetRelative); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSpeedBased", _m_SetSpeedBased); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetOptions", _m_SetOptions); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startValue", _g_get_startValue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "endValue", _g_get_endValue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "changeValue", _g_get_changeValue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "plugOptions", _g_get_plugOptions); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "getter", _g_get_getter); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "setter", _g_get_setter); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startValue", _s_set_startValue); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "endValue", _s_set_endValue); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "changeValue", _s_set_changeValue); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "plugOptions", _s_set_plugOptions); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "getter", _s_set_getter); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "setter", _s_set_setter); + + + 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, "DG.Tweening.Core.TweenerCore does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ChangeStartValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Color _newStartValue;translator.Get(L, 2, out _newStartValue); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Color _newStartValue;translator.Get(L, 2, out _newStartValue); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue ); + 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 DG.Tweening.Core.TweenerCore.ChangeStartValue!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ChangeEndValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Color _newEndValue;translator.Get(L, 2, out _newEndValue); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Color _newEndValue;translator.Get(L, 2, out _newEndValue); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Color _newEndValue;translator.Get(L, 2, out _newEndValue); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Color _newEndValue;translator.Get(L, 2, out _newEndValue); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue ); + 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 DG.Tweening.Core.TweenerCore.ChangeEndValue!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ChangeValues(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + object _newEndValue = translator.GetObject(L, 3, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + object _newEndValue = translator.GetObject(L, 3, typeof(object)); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Color _newStartValue;translator.Get(L, 2, out _newStartValue); + UnityEngine.Color _newEndValue;translator.Get(L, 3, out _newEndValue); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Color _newStartValue;translator.Get(L, 2, out _newStartValue); + UnityEngine.Color _newEndValue;translator.Get(L, 3, out _newEndValue); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue ); + 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 DG.Tweening.Core.TweenerCore.ChangeValues!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Pause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Pause( ); + 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_Play(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Play( ); + 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_SetAutoKill(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetAutoKill( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _autoKillOnCompletion = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetAutoKill( _autoKillOnCompletion ); + 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 DG.Tweening.Core.TweenerCore.SetAutoKill!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _intId = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.SetId( _intId ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _objectId = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.SetId( _objectId ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _stringId = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.SetId( _stringId ); + 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 DG.Tweening.Core.TweenerCore.SetId!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLink(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.GameObject _gameObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + var gen_ret = gen_to_be_invoked.SetLink( _gameObject ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.GameObject _gameObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + DG.Tweening.LinkBehaviour _behaviour;translator.Get(L, 3, out _behaviour); + + var gen_ret = gen_to_be_invoked.SetLink( _gameObject, _behaviour ); + 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 DG.Tweening.Core.TweenerCore.SetLink!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTarget(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + object _target = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.SetTarget( _target ); + 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_SetLoops(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _loops = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.SetLoops( _loops ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _loops = LuaAPI.xlua_tointeger(L, 2); + DG.Tweening.LoopType _loopType;translator.Get(L, 3, out _loopType); + + var gen_ret = gen_to_be_invoked.SetLoops( _loops, _loopType ); + 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 DG.Tweening.Core.TweenerCore.SetLoops!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetEase(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + + var gen_ret = gen_to_be_invoked.SetEase( _ease ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.AnimationCurve _animCurve = (UnityEngine.AnimationCurve)translator.GetObject(L, 2, typeof(UnityEngine.AnimationCurve)); + + var gen_ret = gen_to_be_invoked.SetEase( _animCurve ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.EaseFunction _customEase = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.SetEase( _customEase ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + float _overshoot = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.SetEase( _ease, _overshoot ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + float _amplitude = (float)LuaAPI.lua_tonumber(L, 3); + float _period = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.SetEase( _ease, _amplitude, _period ); + 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 DG.Tweening.Core.TweenerCore.SetEase!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRecyclable(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetRecyclable( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _recyclable = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetRecyclable( _recyclable ); + 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 DG.Tweening.Core.TweenerCore.SetRecyclable!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isIndependentUpdate = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetUpdate( _isIndependentUpdate ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.UpdateType _updateType;translator.Get(L, 2, out _updateType); + + var gen_ret = gen_to_be_invoked.SetUpdate( _updateType ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.UpdateType _updateType;translator.Get(L, 2, out _updateType); + bool _isIndependentUpdate = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.SetUpdate( _updateType, _isIndependentUpdate ); + 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 DG.Tweening.Core.TweenerCore.SetUpdate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnStart(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnStart( _action ); + 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_OnPlay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnPlay( _action ); + 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_OnPause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnPause( _action ); + 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_OnRewind(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnRewind( _action ); + 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_OnUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnUpdate( _action ); + 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_OnStepComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnStepComplete( _action ); + 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_OnComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnComplete( _action ); + 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_OnKill(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnKill( _action ); + 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_OnWaypointChange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.OnWaypointChange( _action ); + 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_SetAs(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.Tween _asTween = (DG.Tweening.Tween)translator.GetObject(L, 2, typeof(DG.Tweening.Tween)); + + var gen_ret = gen_to_be_invoked.SetAs( _asTween ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.TweenParams _tweenParams = (DG.Tweening.TweenParams)translator.GetObject(L, 2, typeof(DG.Tweening.TweenParams)); + + var gen_ret = gen_to_be_invoked.SetAs( _tweenParams ); + 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 DG.Tweening.Core.TweenerCore.SetAs!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_From(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.From( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isRelative = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.From( _isRelative ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + float _fromAlphaValue = (float)LuaAPI.lua_tonumber(L, 2); + bool _setImmediately = LuaAPI.lua_toboolean(L, 3); + bool _isRelative = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.From( _fromAlphaValue, _setImmediately, _isRelative ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + float _fromAlphaValue = (float)LuaAPI.lua_tonumber(L, 2); + bool _setImmediately = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.From( _fromAlphaValue, _setImmediately ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _fromAlphaValue = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.From( _fromAlphaValue ); + 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 DG.Tweening.Core.TweenerCore.From!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetDelay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _delay = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.SetDelay( _delay ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + float _delay = (float)LuaAPI.lua_tonumber(L, 2); + bool _asPrependedIntervalIfSequence = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.SetDelay( _delay, _asPrependedIntervalIfSequence ); + 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 DG.Tweening.Core.TweenerCore.SetDelay!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRelative(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetRelative( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isRelative = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetRelative( _isRelative ); + 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 DG.Tweening.Core.TweenerCore.SetRelative!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSpeedBased(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetSpeedBased( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isSpeedBased = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetSpeedBased( _isSpeedBased ); + 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 DG.Tweening.Core.TweenerCore.SetSpeedBased!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetOptions(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + bool _alphaOnly = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetOptions( _alphaOnly ); + 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_startValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineColor(L, gen_to_be_invoked.startValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_endValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineColor(L, gen_to_be_invoked.endValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_changeValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineColor(L, gen_to_be_invoked.changeValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_plugOptions(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.plugOptions); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_getter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.getter); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_setter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.setter); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + UnityEngine.Color gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.startValue = 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_endValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + UnityEngine.Color gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.endValue = 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_changeValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + UnityEngine.Color gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.changeValue = 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_plugOptions(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + DG.Tweening.Plugins.Options.ColorOptions gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.plugOptions = 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_getter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.getter = translator.GetDelegate>(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_setter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.setter = translator.GetDelegate>(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/DG_Tweening_Core_TweenerCore_3_UnityEngine_Quaternion_UnityEngine_Vector3_DG_Tweening_Plugins_Options_QuaternionOptions_Wrap.cs b/Assets/XLua/Gen/DG_Tweening_Core_TweenerCore_3_UnityEngine_Quaternion_UnityEngine_Vector3_DG_Tweening_Plugins_Options_QuaternionOptions_Wrap.cs new file mode 100644 index 000000000..b65042e86 --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_Core_TweenerCore_3_UnityEngine_Quaternion_UnityEngine_Vector3_DG_Tweening_Plugins_Options_QuaternionOptions_Wrap.cs @@ -0,0 +1,1517 @@ +#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; +using DG.Tweening; + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class DGTweeningCoreTweenerCore_3_UnityEngineQuaternionUnityEngineVector3DGTweeningPluginsOptionsQuaternionOptions_Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.Core.TweenerCore); + Utils.BeginObjectRegister(type, L, translator, 0, 28, 6, 6); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ChangeStartValue", _m_ChangeStartValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ChangeEndValue", _m_ChangeEndValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ChangeValues", _m_ChangeValues); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Pause", _m_Pause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Play", _m_Play); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAutoKill", _m_SetAutoKill); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetId", _m_SetId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLink", _m_SetLink); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTarget", _m_SetTarget); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLoops", _m_SetLoops); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetEase", _m_SetEase); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRecyclable", _m_SetRecyclable); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetUpdate", _m_SetUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnStart", _m_OnStart); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPlay", _m_OnPlay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPause", _m_OnPause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRewind", _m_OnRewind); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnUpdate", _m_OnUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnStepComplete", _m_OnStepComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnComplete", _m_OnComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnKill", _m_OnKill); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnWaypointChange", _m_OnWaypointChange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAs", _m_SetAs); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "From", _m_From); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetDelay", _m_SetDelay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRelative", _m_SetRelative); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSpeedBased", _m_SetSpeedBased); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetOptions", _m_SetOptions); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startValue", _g_get_startValue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "endValue", _g_get_endValue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "changeValue", _g_get_changeValue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "plugOptions", _g_get_plugOptions); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "getter", _g_get_getter); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "setter", _g_get_setter); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startValue", _s_set_startValue); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "endValue", _s_set_endValue); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "changeValue", _s_set_changeValue); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "plugOptions", _s_set_plugOptions); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "getter", _s_set_getter); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "setter", _s_set_setter); + + + 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, "DG.Tweening.Core.TweenerCore does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ChangeStartValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _newStartValue;translator.Get(L, 2, out _newStartValue); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _newStartValue;translator.Get(L, 2, out _newStartValue); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue ); + 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 DG.Tweening.Core.TweenerCore.ChangeStartValue!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ChangeEndValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _newEndValue;translator.Get(L, 2, out _newEndValue); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3 _newEndValue;translator.Get(L, 2, out _newEndValue); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _newEndValue;translator.Get(L, 2, out _newEndValue); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _newEndValue;translator.Get(L, 2, out _newEndValue); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue ); + 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 DG.Tweening.Core.TweenerCore.ChangeEndValue!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ChangeValues(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + object _newEndValue = translator.GetObject(L, 3, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + object _newEndValue = translator.GetObject(L, 3, typeof(object)); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3 _newStartValue;translator.Get(L, 2, out _newStartValue); + UnityEngine.Vector3 _newEndValue;translator.Get(L, 3, out _newEndValue); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _newStartValue;translator.Get(L, 2, out _newStartValue); + UnityEngine.Vector3 _newEndValue;translator.Get(L, 3, out _newEndValue); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue ); + 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 DG.Tweening.Core.TweenerCore.ChangeValues!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Pause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Pause( ); + 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_Play(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Play( ); + 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_SetAutoKill(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetAutoKill( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _autoKillOnCompletion = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetAutoKill( _autoKillOnCompletion ); + 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 DG.Tweening.Core.TweenerCore.SetAutoKill!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _intId = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.SetId( _intId ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _objectId = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.SetId( _objectId ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _stringId = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.SetId( _stringId ); + 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 DG.Tweening.Core.TweenerCore.SetId!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLink(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.GameObject _gameObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + var gen_ret = gen_to_be_invoked.SetLink( _gameObject ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.GameObject _gameObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + DG.Tweening.LinkBehaviour _behaviour;translator.Get(L, 3, out _behaviour); + + var gen_ret = gen_to_be_invoked.SetLink( _gameObject, _behaviour ); + 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 DG.Tweening.Core.TweenerCore.SetLink!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTarget(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + object _target = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.SetTarget( _target ); + 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_SetLoops(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _loops = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.SetLoops( _loops ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _loops = LuaAPI.xlua_tointeger(L, 2); + DG.Tweening.LoopType _loopType;translator.Get(L, 3, out _loopType); + + var gen_ret = gen_to_be_invoked.SetLoops( _loops, _loopType ); + 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 DG.Tweening.Core.TweenerCore.SetLoops!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetEase(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + + var gen_ret = gen_to_be_invoked.SetEase( _ease ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.AnimationCurve _animCurve = (UnityEngine.AnimationCurve)translator.GetObject(L, 2, typeof(UnityEngine.AnimationCurve)); + + var gen_ret = gen_to_be_invoked.SetEase( _animCurve ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.EaseFunction _customEase = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.SetEase( _customEase ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + float _overshoot = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.SetEase( _ease, _overshoot ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + float _amplitude = (float)LuaAPI.lua_tonumber(L, 3); + float _period = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.SetEase( _ease, _amplitude, _period ); + 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 DG.Tweening.Core.TweenerCore.SetEase!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRecyclable(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetRecyclable( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _recyclable = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetRecyclable( _recyclable ); + 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 DG.Tweening.Core.TweenerCore.SetRecyclable!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isIndependentUpdate = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetUpdate( _isIndependentUpdate ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.UpdateType _updateType;translator.Get(L, 2, out _updateType); + + var gen_ret = gen_to_be_invoked.SetUpdate( _updateType ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.UpdateType _updateType;translator.Get(L, 2, out _updateType); + bool _isIndependentUpdate = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.SetUpdate( _updateType, _isIndependentUpdate ); + 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 DG.Tweening.Core.TweenerCore.SetUpdate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnStart(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnStart( _action ); + 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_OnPlay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnPlay( _action ); + 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_OnPause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnPause( _action ); + 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_OnRewind(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnRewind( _action ); + 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_OnUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnUpdate( _action ); + 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_OnStepComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnStepComplete( _action ); + 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_OnComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnComplete( _action ); + 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_OnKill(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnKill( _action ); + 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_OnWaypointChange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.OnWaypointChange( _action ); + 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_SetAs(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.Tween _asTween = (DG.Tweening.Tween)translator.GetObject(L, 2, typeof(DG.Tweening.Tween)); + + var gen_ret = gen_to_be_invoked.SetAs( _asTween ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.TweenParams _tweenParams = (DG.Tweening.TweenParams)translator.GetObject(L, 2, typeof(DG.Tweening.TweenParams)); + + var gen_ret = gen_to_be_invoked.SetAs( _tweenParams ); + 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 DG.Tweening.Core.TweenerCore.SetAs!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_From(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.From( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isRelative = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.From( _isRelative ); + 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 DG.Tweening.Core.TweenerCore.From!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetDelay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _delay = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.SetDelay( _delay ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + float _delay = (float)LuaAPI.lua_tonumber(L, 2); + bool _asPrependedIntervalIfSequence = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.SetDelay( _delay, _asPrependedIntervalIfSequence ); + 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 DG.Tweening.Core.TweenerCore.SetDelay!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRelative(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetRelative( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isRelative = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetRelative( _isRelative ); + 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 DG.Tweening.Core.TweenerCore.SetRelative!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSpeedBased(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetSpeedBased( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isSpeedBased = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetSpeedBased( _isSpeedBased ); + 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 DG.Tweening.Core.TweenerCore.SetSpeedBased!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetOptions(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _useShortest360Route = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetOptions( _useShortest360Route ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetOptions( ); + 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 DG.Tweening.Core.TweenerCore.SetOptions!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.startValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_endValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.endValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_changeValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.changeValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_plugOptions(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.plugOptions); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_getter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.getter); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_setter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.setter); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.startValue = 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_endValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.endValue = 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_changeValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.changeValue = 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_plugOptions(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + DG.Tweening.Plugins.Options.QuaternionOptions gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.plugOptions = 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_getter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.getter = translator.GetDelegate>(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_setter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.setter = translator.GetDelegate>(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/DG_Tweening_Core_TweenerCore_3_UnityEngine_Vector2_UnityEngine_Vector2_DG_Tweening_Plugins_Options_VectorOptions_Wrap.cs b/Assets/XLua/Gen/DG_Tweening_Core_TweenerCore_3_UnityEngine_Vector2_UnityEngine_Vector2_DG_Tweening_Plugins_Options_VectorOptions_Wrap.cs new file mode 100644 index 000000000..78cb83795 --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_Core_TweenerCore_3_UnityEngine_Vector2_UnityEngine_Vector2_DG_Tweening_Plugins_Options_VectorOptions_Wrap.cs @@ -0,0 +1,1530 @@ +#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; +using DG.Tweening; + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class DGTweeningCoreTweenerCore_3_UnityEngineVector2UnityEngineVector2DGTweeningPluginsOptionsVectorOptions_Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.Core.TweenerCore); + Utils.BeginObjectRegister(type, L, translator, 0, 28, 6, 6); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ChangeStartValue", _m_ChangeStartValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ChangeEndValue", _m_ChangeEndValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ChangeValues", _m_ChangeValues); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Pause", _m_Pause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Play", _m_Play); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAutoKill", _m_SetAutoKill); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetId", _m_SetId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLink", _m_SetLink); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTarget", _m_SetTarget); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLoops", _m_SetLoops); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetEase", _m_SetEase); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRecyclable", _m_SetRecyclable); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetUpdate", _m_SetUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnStart", _m_OnStart); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPlay", _m_OnPlay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPause", _m_OnPause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRewind", _m_OnRewind); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnUpdate", _m_OnUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnStepComplete", _m_OnStepComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnComplete", _m_OnComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnKill", _m_OnKill); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnWaypointChange", _m_OnWaypointChange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAs", _m_SetAs); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "From", _m_From); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetDelay", _m_SetDelay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRelative", _m_SetRelative); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSpeedBased", _m_SetSpeedBased); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetOptions", _m_SetOptions); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startValue", _g_get_startValue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "endValue", _g_get_endValue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "changeValue", _g_get_changeValue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "plugOptions", _g_get_plugOptions); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "getter", _g_get_getter); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "setter", _g_get_setter); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startValue", _s_set_startValue); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "endValue", _s_set_endValue); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "changeValue", _s_set_changeValue); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "plugOptions", _s_set_plugOptions); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "getter", _s_set_getter); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "setter", _s_set_setter); + + + 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, "DG.Tweening.Core.TweenerCore does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ChangeStartValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector2 _newStartValue;translator.Get(L, 2, out _newStartValue); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector2 _newStartValue;translator.Get(L, 2, out _newStartValue); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue ); + 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 DG.Tweening.Core.TweenerCore.ChangeStartValue!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ChangeEndValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector2 _newEndValue;translator.Get(L, 2, out _newEndValue); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector2 _newEndValue;translator.Get(L, 2, out _newEndValue); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector2 _newEndValue;translator.Get(L, 2, out _newEndValue); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector2 _newEndValue;translator.Get(L, 2, out _newEndValue); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue ); + 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 DG.Tweening.Core.TweenerCore.ChangeEndValue!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ChangeValues(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + object _newEndValue = translator.GetObject(L, 3, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + object _newEndValue = translator.GetObject(L, 3, typeof(object)); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector2 _newStartValue;translator.Get(L, 2, out _newStartValue); + UnityEngine.Vector2 _newEndValue;translator.Get(L, 3, out _newEndValue); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector2 _newStartValue;translator.Get(L, 2, out _newStartValue); + UnityEngine.Vector2 _newEndValue;translator.Get(L, 3, out _newEndValue); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue ); + 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 DG.Tweening.Core.TweenerCore.ChangeValues!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Pause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Pause( ); + 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_Play(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Play( ); + 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_SetAutoKill(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetAutoKill( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _autoKillOnCompletion = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetAutoKill( _autoKillOnCompletion ); + 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 DG.Tweening.Core.TweenerCore.SetAutoKill!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _intId = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.SetId( _intId ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _objectId = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.SetId( _objectId ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _stringId = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.SetId( _stringId ); + 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 DG.Tweening.Core.TweenerCore.SetId!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLink(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.GameObject _gameObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + var gen_ret = gen_to_be_invoked.SetLink( _gameObject ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.GameObject _gameObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + DG.Tweening.LinkBehaviour _behaviour;translator.Get(L, 3, out _behaviour); + + var gen_ret = gen_to_be_invoked.SetLink( _gameObject, _behaviour ); + 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 DG.Tweening.Core.TweenerCore.SetLink!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTarget(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + object _target = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.SetTarget( _target ); + 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_SetLoops(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _loops = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.SetLoops( _loops ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _loops = LuaAPI.xlua_tointeger(L, 2); + DG.Tweening.LoopType _loopType;translator.Get(L, 3, out _loopType); + + var gen_ret = gen_to_be_invoked.SetLoops( _loops, _loopType ); + 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 DG.Tweening.Core.TweenerCore.SetLoops!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetEase(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + + var gen_ret = gen_to_be_invoked.SetEase( _ease ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.AnimationCurve _animCurve = (UnityEngine.AnimationCurve)translator.GetObject(L, 2, typeof(UnityEngine.AnimationCurve)); + + var gen_ret = gen_to_be_invoked.SetEase( _animCurve ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.EaseFunction _customEase = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.SetEase( _customEase ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + float _overshoot = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.SetEase( _ease, _overshoot ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + float _amplitude = (float)LuaAPI.lua_tonumber(L, 3); + float _period = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.SetEase( _ease, _amplitude, _period ); + 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 DG.Tweening.Core.TweenerCore.SetEase!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRecyclable(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetRecyclable( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _recyclable = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetRecyclable( _recyclable ); + 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 DG.Tweening.Core.TweenerCore.SetRecyclable!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isIndependentUpdate = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetUpdate( _isIndependentUpdate ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.UpdateType _updateType;translator.Get(L, 2, out _updateType); + + var gen_ret = gen_to_be_invoked.SetUpdate( _updateType ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.UpdateType _updateType;translator.Get(L, 2, out _updateType); + bool _isIndependentUpdate = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.SetUpdate( _updateType, _isIndependentUpdate ); + 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 DG.Tweening.Core.TweenerCore.SetUpdate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnStart(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnStart( _action ); + 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_OnPlay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnPlay( _action ); + 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_OnPause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnPause( _action ); + 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_OnRewind(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnRewind( _action ); + 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_OnUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnUpdate( _action ); + 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_OnStepComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnStepComplete( _action ); + 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_OnComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnComplete( _action ); + 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_OnKill(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnKill( _action ); + 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_OnWaypointChange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.OnWaypointChange( _action ); + 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_SetAs(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.Tween _asTween = (DG.Tweening.Tween)translator.GetObject(L, 2, typeof(DG.Tweening.Tween)); + + var gen_ret = gen_to_be_invoked.SetAs( _asTween ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.TweenParams _tweenParams = (DG.Tweening.TweenParams)translator.GetObject(L, 2, typeof(DG.Tweening.TweenParams)); + + var gen_ret = gen_to_be_invoked.SetAs( _tweenParams ); + 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 DG.Tweening.Core.TweenerCore.SetAs!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_From(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.From( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isRelative = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.From( _isRelative ); + 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 DG.Tweening.Core.TweenerCore.From!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetDelay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _delay = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.SetDelay( _delay ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + float _delay = (float)LuaAPI.lua_tonumber(L, 2); + bool _asPrependedIntervalIfSequence = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.SetDelay( _delay, _asPrependedIntervalIfSequence ); + 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 DG.Tweening.Core.TweenerCore.SetDelay!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRelative(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetRelative( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isRelative = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetRelative( _isRelative ); + 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 DG.Tweening.Core.TweenerCore.SetRelative!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSpeedBased(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetSpeedBased( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isSpeedBased = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetSpeedBased( _isSpeedBased ); + 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 DG.Tweening.Core.TweenerCore.SetSpeedBased!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetOptions(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _snapping = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetOptions( _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.AxisConstraint _axisConstraint;translator.Get(L, 2, out _axisConstraint); + bool _snapping = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.SetOptions( _axisConstraint, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.AxisConstraint _axisConstraint;translator.Get(L, 2, out _axisConstraint); + + var gen_ret = gen_to_be_invoked.SetOptions( _axisConstraint ); + 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 DG.Tweening.Core.TweenerCore.SetOptions!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.startValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_endValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.endValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_changeValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.changeValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_plugOptions(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.plugOptions); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_getter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.getter); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_setter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.setter); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.startValue = 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_endValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.endValue = 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_changeValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.changeValue = 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_plugOptions(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + DG.Tweening.Plugins.Options.VectorOptions gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.plugOptions = 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_getter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.getter = translator.GetDelegate>(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_setter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.setter = translator.GetDelegate>(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/DG_Tweening_Core_TweenerCore_3_UnityEngine_Vector3_DG_Tweening_Plugins_Core_PathCore_Path_DG_Tweening_Plugins_Options_PathOptions_Wrap.cs b/Assets/XLua/Gen/DG_Tweening_Core_TweenerCore_3_UnityEngine_Vector3_DG_Tweening_Plugins_Core_PathCore_Path_DG_Tweening_Plugins_Options_PathOptions_Wrap.cs new file mode 100644 index 000000000..83df06aca --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_Core_TweenerCore_3_UnityEngine_Vector3_DG_Tweening_Plugins_Core_PathCore_Path_DG_Tweening_Plugins_Options_PathOptions_Wrap.cs @@ -0,0 +1,1719 @@ +#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; +using DG.Tweening; + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class DGTweeningCoreTweenerCore_3_UnityEngineVector3DGTweeningPluginsCorePathCorePathDGTweeningPluginsOptionsPathOptions_Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.Core.TweenerCore); + Utils.BeginObjectRegister(type, L, translator, 0, 29, 6, 6); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ChangeStartValue", _m_ChangeStartValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ChangeEndValue", _m_ChangeEndValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ChangeValues", _m_ChangeValues); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Pause", _m_Pause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Play", _m_Play); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAutoKill", _m_SetAutoKill); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetId", _m_SetId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLink", _m_SetLink); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTarget", _m_SetTarget); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLoops", _m_SetLoops); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetEase", _m_SetEase); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRecyclable", _m_SetRecyclable); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetUpdate", _m_SetUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnStart", _m_OnStart); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPlay", _m_OnPlay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPause", _m_OnPause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRewind", _m_OnRewind); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnUpdate", _m_OnUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnStepComplete", _m_OnStepComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnComplete", _m_OnComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnKill", _m_OnKill); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnWaypointChange", _m_OnWaypointChange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAs", _m_SetAs); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "From", _m_From); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetDelay", _m_SetDelay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRelative", _m_SetRelative); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSpeedBased", _m_SetSpeedBased); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetOptions", _m_SetOptions); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLookAt", _m_SetLookAt); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startValue", _g_get_startValue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "endValue", _g_get_endValue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "changeValue", _g_get_changeValue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "plugOptions", _g_get_plugOptions); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "getter", _g_get_getter); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "setter", _g_get_setter); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startValue", _s_set_startValue); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "endValue", _s_set_endValue); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "changeValue", _s_set_changeValue); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "plugOptions", _s_set_plugOptions); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "getter", _s_set_getter); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "setter", _s_set_setter); + + + 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, "DG.Tweening.Core.TweenerCore does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ChangeStartValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.Plugins.Core.PathCore.Path _newStartValue = (DG.Tweening.Plugins.Core.PathCore.Path)translator.GetObject(L, 2, typeof(DG.Tweening.Plugins.Core.PathCore.Path)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.Plugins.Core.PathCore.Path _newStartValue = (DG.Tweening.Plugins.Core.PathCore.Path)translator.GetObject(L, 2, typeof(DG.Tweening.Plugins.Core.PathCore.Path)); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue ); + 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 DG.Tweening.Core.TweenerCore.ChangeStartValue!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ChangeEndValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.Plugins.Core.PathCore.Path _newEndValue = (DG.Tweening.Plugins.Core.PathCore.Path)translator.GetObject(L, 2, typeof(DG.Tweening.Plugins.Core.PathCore.Path)); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Plugins.Core.PathCore.Path _newEndValue = (DG.Tweening.Plugins.Core.PathCore.Path)translator.GetObject(L, 2, typeof(DG.Tweening.Plugins.Core.PathCore.Path)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.Plugins.Core.PathCore.Path _newEndValue = (DG.Tweening.Plugins.Core.PathCore.Path)translator.GetObject(L, 2, typeof(DG.Tweening.Plugins.Core.PathCore.Path)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.Plugins.Core.PathCore.Path _newEndValue = (DG.Tweening.Plugins.Core.PathCore.Path)translator.GetObject(L, 2, typeof(DG.Tweening.Plugins.Core.PathCore.Path)); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue ); + 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 DG.Tweening.Core.TweenerCore.ChangeEndValue!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ChangeValues(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + object _newEndValue = translator.GetObject(L, 3, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + object _newEndValue = translator.GetObject(L, 3, typeof(object)); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Plugins.Core.PathCore.Path _newStartValue = (DG.Tweening.Plugins.Core.PathCore.Path)translator.GetObject(L, 2, typeof(DG.Tweening.Plugins.Core.PathCore.Path)); + DG.Tweening.Plugins.Core.PathCore.Path _newEndValue = (DG.Tweening.Plugins.Core.PathCore.Path)translator.GetObject(L, 3, typeof(DG.Tweening.Plugins.Core.PathCore.Path)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + DG.Tweening.Plugins.Core.PathCore.Path _newStartValue = (DG.Tweening.Plugins.Core.PathCore.Path)translator.GetObject(L, 2, typeof(DG.Tweening.Plugins.Core.PathCore.Path)); + DG.Tweening.Plugins.Core.PathCore.Path _newEndValue = (DG.Tweening.Plugins.Core.PathCore.Path)translator.GetObject(L, 3, typeof(DG.Tweening.Plugins.Core.PathCore.Path)); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue ); + 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 DG.Tweening.Core.TweenerCore.ChangeValues!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Pause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Pause( ); + 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_Play(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Play( ); + 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_SetAutoKill(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetAutoKill( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _autoKillOnCompletion = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetAutoKill( _autoKillOnCompletion ); + 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 DG.Tweening.Core.TweenerCore.SetAutoKill!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _intId = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.SetId( _intId ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _objectId = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.SetId( _objectId ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _stringId = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.SetId( _stringId ); + 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 DG.Tweening.Core.TweenerCore.SetId!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLink(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.GameObject _gameObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + var gen_ret = gen_to_be_invoked.SetLink( _gameObject ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.GameObject _gameObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + DG.Tweening.LinkBehaviour _behaviour;translator.Get(L, 3, out _behaviour); + + var gen_ret = gen_to_be_invoked.SetLink( _gameObject, _behaviour ); + 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 DG.Tweening.Core.TweenerCore.SetLink!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTarget(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + object _target = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.SetTarget( _target ); + 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_SetLoops(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _loops = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.SetLoops( _loops ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _loops = LuaAPI.xlua_tointeger(L, 2); + DG.Tweening.LoopType _loopType;translator.Get(L, 3, out _loopType); + + var gen_ret = gen_to_be_invoked.SetLoops( _loops, _loopType ); + 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 DG.Tweening.Core.TweenerCore.SetLoops!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetEase(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + + var gen_ret = gen_to_be_invoked.SetEase( _ease ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.AnimationCurve _animCurve = (UnityEngine.AnimationCurve)translator.GetObject(L, 2, typeof(UnityEngine.AnimationCurve)); + + var gen_ret = gen_to_be_invoked.SetEase( _animCurve ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.EaseFunction _customEase = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.SetEase( _customEase ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + float _overshoot = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.SetEase( _ease, _overshoot ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + float _amplitude = (float)LuaAPI.lua_tonumber(L, 3); + float _period = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.SetEase( _ease, _amplitude, _period ); + 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 DG.Tweening.Core.TweenerCore.SetEase!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRecyclable(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetRecyclable( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _recyclable = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetRecyclable( _recyclable ); + 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 DG.Tweening.Core.TweenerCore.SetRecyclable!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isIndependentUpdate = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetUpdate( _isIndependentUpdate ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.UpdateType _updateType;translator.Get(L, 2, out _updateType); + + var gen_ret = gen_to_be_invoked.SetUpdate( _updateType ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.UpdateType _updateType;translator.Get(L, 2, out _updateType); + bool _isIndependentUpdate = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.SetUpdate( _updateType, _isIndependentUpdate ); + 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 DG.Tweening.Core.TweenerCore.SetUpdate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnStart(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnStart( _action ); + 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_OnPlay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnPlay( _action ); + 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_OnPause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnPause( _action ); + 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_OnRewind(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnRewind( _action ); + 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_OnUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnUpdate( _action ); + 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_OnStepComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnStepComplete( _action ); + 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_OnComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnComplete( _action ); + 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_OnKill(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnKill( _action ); + 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_OnWaypointChange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.OnWaypointChange( _action ); + 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_SetAs(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.Tween _asTween = (DG.Tweening.Tween)translator.GetObject(L, 2, typeof(DG.Tweening.Tween)); + + var gen_ret = gen_to_be_invoked.SetAs( _asTween ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.TweenParams _tweenParams = (DG.Tweening.TweenParams)translator.GetObject(L, 2, typeof(DG.Tweening.TweenParams)); + + var gen_ret = gen_to_be_invoked.SetAs( _tweenParams ); + 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 DG.Tweening.Core.TweenerCore.SetAs!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_From(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.From( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isRelative = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.From( _isRelative ); + 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 DG.Tweening.Core.TweenerCore.From!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetDelay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _delay = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.SetDelay( _delay ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + float _delay = (float)LuaAPI.lua_tonumber(L, 2); + bool _asPrependedIntervalIfSequence = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.SetDelay( _delay, _asPrependedIntervalIfSequence ); + 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 DG.Tweening.Core.TweenerCore.SetDelay!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRelative(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetRelative( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isRelative = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetRelative( _isRelative ); + 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 DG.Tweening.Core.TweenerCore.SetRelative!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSpeedBased(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetSpeedBased( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isSpeedBased = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetSpeedBased( _isSpeedBased ); + 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 DG.Tweening.Core.TweenerCore.SetSpeedBased!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetOptions(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + DG.Tweening.AxisConstraint _lockPosition;translator.Get(L, 2, out _lockPosition); + DG.Tweening.AxisConstraint _lockRotation;translator.Get(L, 3, out _lockRotation); + + var gen_ret = gen_to_be_invoked.SetOptions( _lockPosition, _lockRotation ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.AxisConstraint _lockPosition;translator.Get(L, 2, out _lockPosition); + + var gen_ret = gen_to_be_invoked.SetOptions( _lockPosition ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + bool _closePath = LuaAPI.lua_toboolean(L, 2); + DG.Tweening.AxisConstraint _lockPosition;translator.Get(L, 3, out _lockPosition); + DG.Tweening.AxisConstraint _lockRotation;translator.Get(L, 4, out _lockRotation); + + var gen_ret = gen_to_be_invoked.SetOptions( _closePath, _lockPosition, _lockRotation ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + bool _closePath = LuaAPI.lua_toboolean(L, 2); + DG.Tweening.AxisConstraint _lockPosition;translator.Get(L, 3, out _lockPosition); + + var gen_ret = gen_to_be_invoked.SetOptions( _closePath, _lockPosition ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _closePath = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetOptions( _closePath ); + 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 DG.Tweening.Core.TweenerCore.SetOptions!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLookAt(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + float _lookAhead = (float)LuaAPI.lua_tonumber(L, 2); + bool _stableZRotation = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.SetLookAt( _lookAhead, _stableZRotation ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _lookAtPosition;translator.Get(L, 2, out _lookAtPosition); + bool _stableZRotation = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.SetLookAt( _lookAtPosition, _stableZRotation ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Transform _lookAtTransform = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + bool _stableZRotation = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.SetLookAt( _lookAtTransform, _stableZRotation ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)&& translator.Assignable>(L, 4)) + { + float _lookAhead = (float)LuaAPI.lua_tonumber(L, 2); + System.Nullable _forwardDirection;translator.Get(L, 3, out _forwardDirection); + System.Nullable _up;translator.Get(L, 4, out _up); + + var gen_ret = gen_to_be_invoked.SetLookAt( _lookAhead, _forwardDirection, _up ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + float _lookAhead = (float)LuaAPI.lua_tonumber(L, 2); + System.Nullable _forwardDirection;translator.Get(L, 3, out _forwardDirection); + + var gen_ret = gen_to_be_invoked.SetLookAt( _lookAhead, _forwardDirection ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _lookAhead = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.SetLookAt( _lookAhead ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable>(L, 3)&& translator.Assignable>(L, 4)) + { + UnityEngine.Vector3 _lookAtPosition;translator.Get(L, 2, out _lookAtPosition); + System.Nullable _forwardDirection;translator.Get(L, 3, out _forwardDirection); + System.Nullable _up;translator.Get(L, 4, out _up); + + var gen_ret = gen_to_be_invoked.SetLookAt( _lookAtPosition, _forwardDirection, _up ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable>(L, 3)) + { + UnityEngine.Vector3 _lookAtPosition;translator.Get(L, 2, out _lookAtPosition); + System.Nullable _forwardDirection;translator.Get(L, 3, out _forwardDirection); + + var gen_ret = gen_to_be_invoked.SetLookAt( _lookAtPosition, _forwardDirection ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _lookAtPosition;translator.Get(L, 2, out _lookAtPosition); + + var gen_ret = gen_to_be_invoked.SetLookAt( _lookAtPosition ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable>(L, 3)&& translator.Assignable>(L, 4)) + { + UnityEngine.Transform _lookAtTransform = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + System.Nullable _forwardDirection;translator.Get(L, 3, out _forwardDirection); + System.Nullable _up;translator.Get(L, 4, out _up); + + var gen_ret = gen_to_be_invoked.SetLookAt( _lookAtTransform, _forwardDirection, _up ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable>(L, 3)) + { + UnityEngine.Transform _lookAtTransform = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + System.Nullable _forwardDirection;translator.Get(L, 3, out _forwardDirection); + + var gen_ret = gen_to_be_invoked.SetLookAt( _lookAtTransform, _forwardDirection ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Transform _lookAtTransform = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + + var gen_ret = gen_to_be_invoked.SetLookAt( _lookAtTransform ); + 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 DG.Tweening.Core.TweenerCore.SetLookAt!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.startValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_endValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.endValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_changeValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.changeValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_plugOptions(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.plugOptions); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_getter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.getter); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_setter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.setter); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.startValue = (DG.Tweening.Plugins.Core.PathCore.Path)translator.GetObject(L, 2, typeof(DG.Tweening.Plugins.Core.PathCore.Path)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_endValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.endValue = (DG.Tweening.Plugins.Core.PathCore.Path)translator.GetObject(L, 2, typeof(DG.Tweening.Plugins.Core.PathCore.Path)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_changeValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.changeValue = (DG.Tweening.Plugins.Core.PathCore.Path)translator.GetObject(L, 2, typeof(DG.Tweening.Plugins.Core.PathCore.Path)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_plugOptions(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + DG.Tweening.Plugins.Options.PathOptions gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.plugOptions = 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_getter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.getter = translator.GetDelegate>(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_setter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.setter = translator.GetDelegate>(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/DG_Tweening_Core_TweenerCore_3_UnityEngine_Vector3_UnityEngine_Vector3_DG_Tweening_Plugins_Options_VectorOptions_Wrap.cs b/Assets/XLua/Gen/DG_Tweening_Core_TweenerCore_3_UnityEngine_Vector3_UnityEngine_Vector3_DG_Tweening_Plugins_Options_VectorOptions_Wrap.cs new file mode 100644 index 000000000..b4c6db383 --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_Core_TweenerCore_3_UnityEngine_Vector3_UnityEngine_Vector3_DG_Tweening_Plugins_Options_VectorOptions_Wrap.cs @@ -0,0 +1,1566 @@ +#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; +using DG.Tweening; + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class DGTweeningCoreTweenerCore_3_UnityEngineVector3UnityEngineVector3DGTweeningPluginsOptionsVectorOptions_Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.Core.TweenerCore); + Utils.BeginObjectRegister(type, L, translator, 0, 28, 6, 6); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ChangeStartValue", _m_ChangeStartValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ChangeEndValue", _m_ChangeEndValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ChangeValues", _m_ChangeValues); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Pause", _m_Pause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Play", _m_Play); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAutoKill", _m_SetAutoKill); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetId", _m_SetId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLink", _m_SetLink); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTarget", _m_SetTarget); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLoops", _m_SetLoops); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetEase", _m_SetEase); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRecyclable", _m_SetRecyclable); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetUpdate", _m_SetUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnStart", _m_OnStart); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPlay", _m_OnPlay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPause", _m_OnPause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRewind", _m_OnRewind); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnUpdate", _m_OnUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnStepComplete", _m_OnStepComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnComplete", _m_OnComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnKill", _m_OnKill); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnWaypointChange", _m_OnWaypointChange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAs", _m_SetAs); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "From", _m_From); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetDelay", _m_SetDelay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRelative", _m_SetRelative); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSpeedBased", _m_SetSpeedBased); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetOptions", _m_SetOptions); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startValue", _g_get_startValue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "endValue", _g_get_endValue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "changeValue", _g_get_changeValue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "plugOptions", _g_get_plugOptions); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "getter", _g_get_getter); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "setter", _g_get_setter); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startValue", _s_set_startValue); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "endValue", _s_set_endValue); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "changeValue", _s_set_changeValue); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "plugOptions", _s_set_plugOptions); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "getter", _s_set_getter); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "setter", _s_set_setter); + + + 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, "DG.Tweening.Core.TweenerCore does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ChangeStartValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _newStartValue;translator.Get(L, 2, out _newStartValue); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _newStartValue;translator.Get(L, 2, out _newStartValue); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue ); + 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 DG.Tweening.Core.TweenerCore.ChangeStartValue!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ChangeEndValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _newEndValue;translator.Get(L, 2, out _newEndValue); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3 _newEndValue;translator.Get(L, 2, out _newEndValue); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _newEndValue;translator.Get(L, 2, out _newEndValue); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _newEndValue;translator.Get(L, 2, out _newEndValue); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue ); + 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 DG.Tweening.Core.TweenerCore.ChangeEndValue!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ChangeValues(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + object _newEndValue = translator.GetObject(L, 3, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + object _newEndValue = translator.GetObject(L, 3, typeof(object)); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3 _newStartValue;translator.Get(L, 2, out _newStartValue); + UnityEngine.Vector3 _newEndValue;translator.Get(L, 3, out _newEndValue); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _newStartValue;translator.Get(L, 2, out _newStartValue); + UnityEngine.Vector3 _newEndValue;translator.Get(L, 3, out _newEndValue); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue ); + 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 DG.Tweening.Core.TweenerCore.ChangeValues!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Pause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Pause( ); + 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_Play(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Play( ); + 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_SetAutoKill(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetAutoKill( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _autoKillOnCompletion = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetAutoKill( _autoKillOnCompletion ); + 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 DG.Tweening.Core.TweenerCore.SetAutoKill!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _intId = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.SetId( _intId ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _objectId = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.SetId( _objectId ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _stringId = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.SetId( _stringId ); + 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 DG.Tweening.Core.TweenerCore.SetId!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLink(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.GameObject _gameObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + var gen_ret = gen_to_be_invoked.SetLink( _gameObject ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.GameObject _gameObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + DG.Tweening.LinkBehaviour _behaviour;translator.Get(L, 3, out _behaviour); + + var gen_ret = gen_to_be_invoked.SetLink( _gameObject, _behaviour ); + 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 DG.Tweening.Core.TweenerCore.SetLink!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTarget(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + object _target = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.SetTarget( _target ); + 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_SetLoops(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _loops = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.SetLoops( _loops ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _loops = LuaAPI.xlua_tointeger(L, 2); + DG.Tweening.LoopType _loopType;translator.Get(L, 3, out _loopType); + + var gen_ret = gen_to_be_invoked.SetLoops( _loops, _loopType ); + 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 DG.Tweening.Core.TweenerCore.SetLoops!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetEase(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + + var gen_ret = gen_to_be_invoked.SetEase( _ease ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.AnimationCurve _animCurve = (UnityEngine.AnimationCurve)translator.GetObject(L, 2, typeof(UnityEngine.AnimationCurve)); + + var gen_ret = gen_to_be_invoked.SetEase( _animCurve ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.EaseFunction _customEase = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.SetEase( _customEase ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + float _overshoot = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.SetEase( _ease, _overshoot ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + float _amplitude = (float)LuaAPI.lua_tonumber(L, 3); + float _period = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.SetEase( _ease, _amplitude, _period ); + 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 DG.Tweening.Core.TweenerCore.SetEase!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRecyclable(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetRecyclable( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _recyclable = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetRecyclable( _recyclable ); + 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 DG.Tweening.Core.TweenerCore.SetRecyclable!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isIndependentUpdate = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetUpdate( _isIndependentUpdate ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.UpdateType _updateType;translator.Get(L, 2, out _updateType); + + var gen_ret = gen_to_be_invoked.SetUpdate( _updateType ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.UpdateType _updateType;translator.Get(L, 2, out _updateType); + bool _isIndependentUpdate = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.SetUpdate( _updateType, _isIndependentUpdate ); + 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 DG.Tweening.Core.TweenerCore.SetUpdate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnStart(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnStart( _action ); + 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_OnPlay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnPlay( _action ); + 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_OnPause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnPause( _action ); + 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_OnRewind(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnRewind( _action ); + 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_OnUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnUpdate( _action ); + 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_OnStepComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnStepComplete( _action ); + 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_OnComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnComplete( _action ); + 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_OnKill(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnKill( _action ); + 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_OnWaypointChange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.OnWaypointChange( _action ); + 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_SetAs(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.Tween _asTween = (DG.Tweening.Tween)translator.GetObject(L, 2, typeof(DG.Tweening.Tween)); + + var gen_ret = gen_to_be_invoked.SetAs( _asTween ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.TweenParams _tweenParams = (DG.Tweening.TweenParams)translator.GetObject(L, 2, typeof(DG.Tweening.TweenParams)); + + var gen_ret = gen_to_be_invoked.SetAs( _tweenParams ); + 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 DG.Tweening.Core.TweenerCore.SetAs!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_From(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.From( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isRelative = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.From( _isRelative ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + float _fromValue = (float)LuaAPI.lua_tonumber(L, 2); + bool _setImmediately = LuaAPI.lua_toboolean(L, 3); + bool _isRelative = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.From( _fromValue, _setImmediately, _isRelative ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + float _fromValue = (float)LuaAPI.lua_tonumber(L, 2); + bool _setImmediately = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.From( _fromValue, _setImmediately ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _fromValue = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.From( _fromValue ); + 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 DG.Tweening.Core.TweenerCore.From!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetDelay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _delay = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.SetDelay( _delay ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + float _delay = (float)LuaAPI.lua_tonumber(L, 2); + bool _asPrependedIntervalIfSequence = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.SetDelay( _delay, _asPrependedIntervalIfSequence ); + 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 DG.Tweening.Core.TweenerCore.SetDelay!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRelative(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetRelative( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isRelative = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetRelative( _isRelative ); + 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 DG.Tweening.Core.TweenerCore.SetRelative!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSpeedBased(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetSpeedBased( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isSpeedBased = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetSpeedBased( _isSpeedBased ); + 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 DG.Tweening.Core.TweenerCore.SetSpeedBased!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetOptions(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _snapping = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetOptions( _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.AxisConstraint _axisConstraint;translator.Get(L, 2, out _axisConstraint); + bool _snapping = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.SetOptions( _axisConstraint, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.AxisConstraint _axisConstraint;translator.Get(L, 2, out _axisConstraint); + + var gen_ret = gen_to_be_invoked.SetOptions( _axisConstraint ); + 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 DG.Tweening.Core.TweenerCore.SetOptions!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.startValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_endValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.endValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_changeValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.changeValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_plugOptions(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.plugOptions); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_getter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.getter); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_setter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.setter); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.startValue = 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_endValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.endValue = 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_changeValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.changeValue = 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_plugOptions(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + DG.Tweening.Plugins.Options.VectorOptions gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.plugOptions = 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_getter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.getter = translator.GetDelegate>(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_setter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.setter = translator.GetDelegate>(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/DG_Tweening_Core_TweenerCore_3_UnityEngine_Vector3_UnityEngine_Vector3___DG_Tweening_Plugins_Options_Vector3ArrayOptions_Wrap.cs b/Assets/XLua/Gen/DG_Tweening_Core_TweenerCore_3_UnityEngine_Vector3_UnityEngine_Vector3___DG_Tweening_Plugins_Options_Vector3ArrayOptions_Wrap.cs new file mode 100644 index 000000000..076d1d39a --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_Core_TweenerCore_3_UnityEngine_Vector3_UnityEngine_Vector3___DG_Tweening_Plugins_Options_Vector3ArrayOptions_Wrap.cs @@ -0,0 +1,1527 @@ +#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; +using DG.Tweening; + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class DGTweeningCoreTweenerCore_3_UnityEngineVector3UnityEngineVector3__DGTweeningPluginsOptionsVector3ArrayOptions_Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.Core.TweenerCore); + Utils.BeginObjectRegister(type, L, translator, 0, 28, 6, 6); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ChangeStartValue", _m_ChangeStartValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ChangeEndValue", _m_ChangeEndValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ChangeValues", _m_ChangeValues); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Pause", _m_Pause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Play", _m_Play); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAutoKill", _m_SetAutoKill); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetId", _m_SetId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLink", _m_SetLink); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTarget", _m_SetTarget); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLoops", _m_SetLoops); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetEase", _m_SetEase); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRecyclable", _m_SetRecyclable); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetUpdate", _m_SetUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnStart", _m_OnStart); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPlay", _m_OnPlay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPause", _m_OnPause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRewind", _m_OnRewind); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnUpdate", _m_OnUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnStepComplete", _m_OnStepComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnComplete", _m_OnComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnKill", _m_OnKill); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnWaypointChange", _m_OnWaypointChange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAs", _m_SetAs); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "From", _m_From); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetDelay", _m_SetDelay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRelative", _m_SetRelative); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSpeedBased", _m_SetSpeedBased); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetOptions", _m_SetOptions); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startValue", _g_get_startValue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "endValue", _g_get_endValue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "changeValue", _g_get_changeValue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "plugOptions", _g_get_plugOptions); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "getter", _g_get_getter); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "setter", _g_get_setter); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startValue", _s_set_startValue); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "endValue", _s_set_endValue); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "changeValue", _s_set_changeValue); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "plugOptions", _s_set_plugOptions); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "getter", _s_set_getter); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "setter", _s_set_setter); + + + 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, "DG.Tweening.Core.TweenerCore does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ChangeStartValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3[] _newStartValue = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3[] _newStartValue = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue ); + 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 DG.Tweening.Core.TweenerCore.ChangeStartValue!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ChangeEndValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3[] _newEndValue = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3[] _newEndValue = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3[] _newEndValue = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3[] _newEndValue = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue ); + 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 DG.Tweening.Core.TweenerCore.ChangeEndValue!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ChangeValues(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + object _newEndValue = translator.GetObject(L, 3, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + object _newEndValue = translator.GetObject(L, 3, typeof(object)); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3[] _newStartValue = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + UnityEngine.Vector3[] _newEndValue = (UnityEngine.Vector3[])translator.GetObject(L, 3, typeof(UnityEngine.Vector3[])); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3[] _newStartValue = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + UnityEngine.Vector3[] _newEndValue = (UnityEngine.Vector3[])translator.GetObject(L, 3, typeof(UnityEngine.Vector3[])); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue ); + 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 DG.Tweening.Core.TweenerCore.ChangeValues!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Pause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Pause( ); + 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_Play(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Play( ); + 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_SetAutoKill(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetAutoKill( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _autoKillOnCompletion = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetAutoKill( _autoKillOnCompletion ); + 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 DG.Tweening.Core.TweenerCore.SetAutoKill!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _intId = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.SetId( _intId ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _objectId = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.SetId( _objectId ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _stringId = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.SetId( _stringId ); + 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 DG.Tweening.Core.TweenerCore.SetId!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLink(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.GameObject _gameObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + var gen_ret = gen_to_be_invoked.SetLink( _gameObject ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.GameObject _gameObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + DG.Tweening.LinkBehaviour _behaviour;translator.Get(L, 3, out _behaviour); + + var gen_ret = gen_to_be_invoked.SetLink( _gameObject, _behaviour ); + 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 DG.Tweening.Core.TweenerCore.SetLink!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTarget(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + object _target = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.SetTarget( _target ); + 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_SetLoops(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _loops = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.SetLoops( _loops ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _loops = LuaAPI.xlua_tointeger(L, 2); + DG.Tweening.LoopType _loopType;translator.Get(L, 3, out _loopType); + + var gen_ret = gen_to_be_invoked.SetLoops( _loops, _loopType ); + 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 DG.Tweening.Core.TweenerCore.SetLoops!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetEase(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + + var gen_ret = gen_to_be_invoked.SetEase( _ease ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.AnimationCurve _animCurve = (UnityEngine.AnimationCurve)translator.GetObject(L, 2, typeof(UnityEngine.AnimationCurve)); + + var gen_ret = gen_to_be_invoked.SetEase( _animCurve ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.EaseFunction _customEase = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.SetEase( _customEase ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + float _overshoot = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.SetEase( _ease, _overshoot ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + float _amplitude = (float)LuaAPI.lua_tonumber(L, 3); + float _period = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.SetEase( _ease, _amplitude, _period ); + 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 DG.Tweening.Core.TweenerCore.SetEase!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRecyclable(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetRecyclable( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _recyclable = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetRecyclable( _recyclable ); + 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 DG.Tweening.Core.TweenerCore.SetRecyclable!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isIndependentUpdate = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetUpdate( _isIndependentUpdate ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.UpdateType _updateType;translator.Get(L, 2, out _updateType); + + var gen_ret = gen_to_be_invoked.SetUpdate( _updateType ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.UpdateType _updateType;translator.Get(L, 2, out _updateType); + bool _isIndependentUpdate = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.SetUpdate( _updateType, _isIndependentUpdate ); + 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 DG.Tweening.Core.TweenerCore.SetUpdate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnStart(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnStart( _action ); + 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_OnPlay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnPlay( _action ); + 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_OnPause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnPause( _action ); + 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_OnRewind(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnRewind( _action ); + 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_OnUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnUpdate( _action ); + 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_OnStepComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnStepComplete( _action ); + 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_OnComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnComplete( _action ); + 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_OnKill(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnKill( _action ); + 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_OnWaypointChange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.OnWaypointChange( _action ); + 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_SetAs(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.Tween _asTween = (DG.Tweening.Tween)translator.GetObject(L, 2, typeof(DG.Tweening.Tween)); + + var gen_ret = gen_to_be_invoked.SetAs( _asTween ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.TweenParams _tweenParams = (DG.Tweening.TweenParams)translator.GetObject(L, 2, typeof(DG.Tweening.TweenParams)); + + var gen_ret = gen_to_be_invoked.SetAs( _tweenParams ); + 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 DG.Tweening.Core.TweenerCore.SetAs!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_From(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.From( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isRelative = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.From( _isRelative ); + 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 DG.Tweening.Core.TweenerCore.From!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetDelay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _delay = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.SetDelay( _delay ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + float _delay = (float)LuaAPI.lua_tonumber(L, 2); + bool _asPrependedIntervalIfSequence = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.SetDelay( _delay, _asPrependedIntervalIfSequence ); + 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 DG.Tweening.Core.TweenerCore.SetDelay!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRelative(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetRelative( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isRelative = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetRelative( _isRelative ); + 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 DG.Tweening.Core.TweenerCore.SetRelative!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSpeedBased(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetSpeedBased( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isSpeedBased = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetSpeedBased( _isSpeedBased ); + 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 DG.Tweening.Core.TweenerCore.SetSpeedBased!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetOptions(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _snapping = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetOptions( _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.AxisConstraint _axisConstraint;translator.Get(L, 2, out _axisConstraint); + bool _snapping = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.SetOptions( _axisConstraint, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.AxisConstraint _axisConstraint;translator.Get(L, 2, out _axisConstraint); + + var gen_ret = gen_to_be_invoked.SetOptions( _axisConstraint ); + 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 DG.Tweening.Core.TweenerCore.SetOptions!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.startValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_endValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.endValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_changeValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.changeValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_plugOptions(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.plugOptions); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_getter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.getter); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_setter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.setter); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.startValue = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_endValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.endValue = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_changeValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.changeValue = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_plugOptions(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + DG.Tweening.Plugins.Options.Vector3ArrayOptions gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.plugOptions = 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_getter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.getter = translator.GetDelegate>(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_setter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Core.TweenerCore gen_to_be_invoked = (DG.Tweening.Core.TweenerCore)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.setter = translator.GetDelegate>(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/DG_Tweening_DOTweenCYInstructionWrap.cs b/Assets/XLua/Gen/DG_Tweening_DOTweenCYInstructionWrap.cs new file mode 100644 index 000000000..dbf3ea4f2 --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_DOTweenCYInstructionWrap.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 DGTweeningDOTweenCYInstructionWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.DOTweenCYInstruction); + 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, "DG.Tweening.DOTweenCYInstruction does not have a constructor!"); + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/DG_Tweening_DOTweenCYInstruction_WaitForCompletionWrap.cs b/Assets/XLua/Gen/DG_Tweening_DOTweenCYInstruction_WaitForCompletionWrap.cs new file mode 100644 index 000000000..78abd4ede --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_DOTweenCYInstruction_WaitForCompletionWrap.cs @@ -0,0 +1,100 @@ +#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 DGTweeningDOTweenCYInstructionWaitForCompletionWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.DOTweenCYInstruction.WaitForCompletion); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 1, 0); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "keepWaiting", _g_get_keepWaiting); + + + + 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) == 2 && translator.Assignable(L, 2)) + { + DG.Tweening.Tween _tween = (DG.Tweening.Tween)translator.GetObject(L, 2, typeof(DG.Tweening.Tween)); + + var gen_ret = new DG.Tweening.DOTweenCYInstruction.WaitForCompletion(_tween); + 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 DG.Tweening.DOTweenCYInstruction.WaitForCompletion constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_keepWaiting(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.DOTweenCYInstruction.WaitForCompletion gen_to_be_invoked = (DG.Tweening.DOTweenCYInstruction.WaitForCompletion)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.keepWaiting); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/DG_Tweening_DOTweenCYInstruction_WaitForElapsedLoopsWrap.cs b/Assets/XLua/Gen/DG_Tweening_DOTweenCYInstruction_WaitForElapsedLoopsWrap.cs new file mode 100644 index 000000000..3dbb9fc35 --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_DOTweenCYInstruction_WaitForElapsedLoopsWrap.cs @@ -0,0 +1,101 @@ +#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 DGTweeningDOTweenCYInstructionWaitForElapsedLoopsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.DOTweenCYInstruction.WaitForElapsedLoops); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 1, 0); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "keepWaiting", _g_get_keepWaiting); + + + + 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 && translator.Assignable(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.Tween _tween = (DG.Tweening.Tween)translator.GetObject(L, 2, typeof(DG.Tweening.Tween)); + int _elapsedLoops = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = new DG.Tweening.DOTweenCYInstruction.WaitForElapsedLoops(_tween, _elapsedLoops); + 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 DG.Tweening.DOTweenCYInstruction.WaitForElapsedLoops constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_keepWaiting(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.DOTweenCYInstruction.WaitForElapsedLoops gen_to_be_invoked = (DG.Tweening.DOTweenCYInstruction.WaitForElapsedLoops)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.keepWaiting); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/DG_Tweening_DOTweenCYInstruction_WaitForKillWrap.cs b/Assets/XLua/Gen/DG_Tweening_DOTweenCYInstruction_WaitForKillWrap.cs new file mode 100644 index 000000000..500c956a0 --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_DOTweenCYInstruction_WaitForKillWrap.cs @@ -0,0 +1,100 @@ +#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 DGTweeningDOTweenCYInstructionWaitForKillWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.DOTweenCYInstruction.WaitForKill); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 1, 0); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "keepWaiting", _g_get_keepWaiting); + + + + 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) == 2 && translator.Assignable(L, 2)) + { + DG.Tweening.Tween _tween = (DG.Tweening.Tween)translator.GetObject(L, 2, typeof(DG.Tweening.Tween)); + + var gen_ret = new DG.Tweening.DOTweenCYInstruction.WaitForKill(_tween); + 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 DG.Tweening.DOTweenCYInstruction.WaitForKill constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_keepWaiting(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.DOTweenCYInstruction.WaitForKill gen_to_be_invoked = (DG.Tweening.DOTweenCYInstruction.WaitForKill)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.keepWaiting); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/DG_Tweening_DOTweenCYInstruction_WaitForPositionWrap.cs b/Assets/XLua/Gen/DG_Tweening_DOTweenCYInstruction_WaitForPositionWrap.cs new file mode 100644 index 000000000..df7d67e89 --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_DOTweenCYInstruction_WaitForPositionWrap.cs @@ -0,0 +1,101 @@ +#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 DGTweeningDOTweenCYInstructionWaitForPositionWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.DOTweenCYInstruction.WaitForPosition); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 1, 0); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "keepWaiting", _g_get_keepWaiting); + + + + 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 && translator.Assignable(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.Tween _tween = (DG.Tweening.Tween)translator.GetObject(L, 2, typeof(DG.Tweening.Tween)); + float _position = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = new DG.Tweening.DOTweenCYInstruction.WaitForPosition(_tween, _position); + 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 DG.Tweening.DOTweenCYInstruction.WaitForPosition constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_keepWaiting(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.DOTweenCYInstruction.WaitForPosition gen_to_be_invoked = (DG.Tweening.DOTweenCYInstruction.WaitForPosition)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.keepWaiting); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/DG_Tweening_DOTweenCYInstruction_WaitForRewindWrap.cs b/Assets/XLua/Gen/DG_Tweening_DOTweenCYInstruction_WaitForRewindWrap.cs new file mode 100644 index 000000000..40c2d49f9 --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_DOTweenCYInstruction_WaitForRewindWrap.cs @@ -0,0 +1,100 @@ +#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 DGTweeningDOTweenCYInstructionWaitForRewindWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.DOTweenCYInstruction.WaitForRewind); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 1, 0); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "keepWaiting", _g_get_keepWaiting); + + + + 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) == 2 && translator.Assignable(L, 2)) + { + DG.Tweening.Tween _tween = (DG.Tweening.Tween)translator.GetObject(L, 2, typeof(DG.Tweening.Tween)); + + var gen_ret = new DG.Tweening.DOTweenCYInstruction.WaitForRewind(_tween); + 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 DG.Tweening.DOTweenCYInstruction.WaitForRewind constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_keepWaiting(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.DOTweenCYInstruction.WaitForRewind gen_to_be_invoked = (DG.Tweening.DOTweenCYInstruction.WaitForRewind)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.keepWaiting); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/DG_Tweening_DOTweenCYInstruction_WaitForStartWrap.cs b/Assets/XLua/Gen/DG_Tweening_DOTweenCYInstruction_WaitForStartWrap.cs new file mode 100644 index 000000000..2e5b8890f --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_DOTweenCYInstruction_WaitForStartWrap.cs @@ -0,0 +1,100 @@ +#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 DGTweeningDOTweenCYInstructionWaitForStartWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.DOTweenCYInstruction.WaitForStart); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 1, 0); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "keepWaiting", _g_get_keepWaiting); + + + + 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) == 2 && translator.Assignable(L, 2)) + { + DG.Tweening.Tween _tween = (DG.Tweening.Tween)translator.GetObject(L, 2, typeof(DG.Tweening.Tween)); + + var gen_ret = new DG.Tweening.DOTweenCYInstruction.WaitForStart(_tween); + 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 DG.Tweening.DOTweenCYInstruction.WaitForStart constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_keepWaiting(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.DOTweenCYInstruction.WaitForStart gen_to_be_invoked = (DG.Tweening.DOTweenCYInstruction.WaitForStart)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.keepWaiting); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/DG_Tweening_DOTweenModuleAudioWrap.cs b/Assets/XLua/Gen/DG_Tweening_DOTweenModuleAudioWrap.cs new file mode 100644 index 000000000..eb750de1d --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_DOTweenModuleAudioWrap.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 DGTweeningDOTweenModuleAudioWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.DOTweenModuleAudio); + 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, "DG.Tweening.DOTweenModuleAudio does not have a constructor!"); + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/DG_Tweening_DOTweenModuleSpriteWrap.cs b/Assets/XLua/Gen/DG_Tweening_DOTweenModuleSpriteWrap.cs new file mode 100644 index 000000000..1d125524a --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_DOTweenModuleSpriteWrap.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 DGTweeningDOTweenModuleSpriteWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.DOTweenModuleSprite); + 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, "DG.Tweening.DOTweenModuleSprite does not have a constructor!"); + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/DG_Tweening_DOTweenModuleUIWrap.cs b/Assets/XLua/Gen/DG_Tweening_DOTweenModuleUIWrap.cs new file mode 100644 index 000000000..62dcd4905 --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_DOTweenModuleUIWrap.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 DGTweeningDOTweenModuleUIWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.DOTweenModuleUI); + 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, "DG.Tweening.DOTweenModuleUI does not have a constructor!"); + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/DG_Tweening_DOTweenModuleUI_UtilsWrap.cs b/Assets/XLua/Gen/DG_Tweening_DOTweenModuleUI_UtilsWrap.cs new file mode 100644 index 000000000..315ca1c23 --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_DOTweenModuleUI_UtilsWrap.cs @@ -0,0 +1,96 @@ +#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 DGTweeningDOTweenModuleUIUtilsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.DOTweenModuleUI.Utils); + 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, "SwitchToRectTransform", _m_SwitchToRectTransform_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "DG.Tweening.DOTweenModuleUI.Utils does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SwitchToRectTransform_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.RectTransform _from = (UnityEngine.RectTransform)translator.GetObject(L, 1, typeof(UnityEngine.RectTransform)); + UnityEngine.RectTransform _to = (UnityEngine.RectTransform)translator.GetObject(L, 2, typeof(UnityEngine.RectTransform)); + + var gen_ret = DG.Tweening.DOTweenModuleUI.Utils.SwitchToRectTransform( _from, _to ); + translator.PushUnityEngineVector2(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/DG_Tweening_DOTweenModuleUnityVersionWrap.cs b/Assets/XLua/Gen/DG_Tweening_DOTweenModuleUnityVersionWrap.cs new file mode 100644 index 000000000..5b2b79086 --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_DOTweenModuleUnityVersionWrap.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 DGTweeningDOTweenModuleUnityVersionWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.DOTweenModuleUnityVersion); + 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, "DG.Tweening.DOTweenModuleUnityVersion does not have a constructor!"); + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/DG_Tweening_DOTweenModuleUtilsWrap.cs b/Assets/XLua/Gen/DG_Tweening_DOTweenModuleUtilsWrap.cs new file mode 100644 index 000000000..9efd167b3 --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_DOTweenModuleUtilsWrap.cs @@ -0,0 +1,91 @@ +#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 DGTweeningDOTweenModuleUtilsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.DOTweenModuleUtils); + 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, "Init", _m_Init_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "DG.Tweening.DOTweenModuleUtils does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Init_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + DG.Tweening.DOTweenModuleUtils.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/DG_Tweening_DOTweenModuleUtils_PhysicsWrap.cs b/Assets/XLua/Gen/DG_Tweening_DOTweenModuleUtils_PhysicsWrap.cs new file mode 100644 index 000000000..0388fc7fd --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_DOTweenModuleUtils_PhysicsWrap.cs @@ -0,0 +1,186 @@ +#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 DGTweeningDOTweenModuleUtilsPhysicsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.DOTweenModuleUtils.Physics); + 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, "SetOrientationOnPath", _m_SetOrientationOnPath_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "HasRigidbody2D", _m_HasRigidbody2D_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "HasRigidbody", _m_HasRigidbody_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CreateDOTweenPathTween", _m_CreateDOTweenPathTween_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "DG.Tweening.DOTweenModuleUtils.Physics does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetOrientationOnPath_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + DG.Tweening.Plugins.Options.PathOptions _options;translator.Get(L, 1, out _options); + DG.Tweening.Tween _t = (DG.Tweening.Tween)translator.GetObject(L, 2, typeof(DG.Tweening.Tween)); + UnityEngine.Quaternion _newRot;translator.Get(L, 3, out _newRot); + UnityEngine.Transform _trans = (UnityEngine.Transform)translator.GetObject(L, 4, typeof(UnityEngine.Transform)); + + DG.Tweening.DOTweenModuleUtils.Physics.SetOrientationOnPath( _options, _t, _newRot, _trans ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasRigidbody2D_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Component _target = (UnityEngine.Component)translator.GetObject(L, 1, typeof(UnityEngine.Component)); + + var gen_ret = DG.Tweening.DOTweenModuleUtils.Physics.HasRigidbody2D( _target ); + 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_HasRigidbody_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Component _target = (UnityEngine.Component)translator.GetObject(L, 1, typeof(UnityEngine.Component)); + + var gen_ret = DG.Tweening.DOTweenModuleUtils.Physics.HasRigidbody( _target ); + 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_CreateDOTweenPathTween_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.MonoBehaviour _target = (UnityEngine.MonoBehaviour)translator.GetObject(L, 1, typeof(UnityEngine.MonoBehaviour)); + bool _tweenRigidbody = LuaAPI.lua_toboolean(L, 2); + bool _isLocal = LuaAPI.lua_toboolean(L, 3); + DG.Tweening.Plugins.Core.PathCore.Path _path = (DG.Tweening.Plugins.Core.PathCore.Path)translator.GetObject(L, 4, typeof(DG.Tweening.Plugins.Core.PathCore.Path)); + float _duration = (float)LuaAPI.lua_tonumber(L, 5); + DG.Tweening.PathMode _pathMode;translator.Get(L, 6, out _pathMode); + + var gen_ret = DG.Tweening.DOTweenModuleUtils.Physics.CreateDOTweenPathTween( _target, _tweenRigidbody, _isLocal, _path, _duration, _pathMode ); + 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/DG_Tweening_DOTweenWrap.cs b/Assets/XLua/Gen/DG_Tweening_DOTweenWrap.cs new file mode 100644 index 000000000..4f021da79 --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_DOTweenWrap.cs @@ -0,0 +1,2652 @@ +#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 DGTweeningDOTweenWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.DOTween); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 45, 21, 21); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Init", _m_Init_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetTweensCapacity", _m_SetTweensCapacity_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Clear", _m_Clear_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ClearCachedTweens", _m_ClearCachedTweens_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Validate", _m_Validate_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ManualUpdate", _m_ManualUpdate_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "To", _m_To_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ToAxis", _m_ToAxis_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ToAlpha", _m_ToAlpha_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Punch", _m_Punch_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Shake", _m_Shake_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ToArray", _m_ToArray_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Sequence", _m_Sequence_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CompleteAll", _m_CompleteAll_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Complete", _m_Complete_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FlipAll", _m_FlipAll_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Flip", _m_Flip_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GotoAll", _m_GotoAll_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Goto", _m_Goto_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "KillAll", _m_KillAll_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Kill", _m_Kill_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "PauseAll", _m_PauseAll_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Pause", _m_Pause_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "PlayAll", _m_PlayAll_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Play", _m_Play_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "PlayBackwardsAll", _m_PlayBackwardsAll_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "PlayBackwards", _m_PlayBackwards_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "PlayForwardAll", _m_PlayForwardAll_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "PlayForward", _m_PlayForward_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RestartAll", _m_RestartAll_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Restart", _m_Restart_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RewindAll", _m_RewindAll_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Rewind", _m_Rewind_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SmoothRewindAll", _m_SmoothRewindAll_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SmoothRewind", _m_SmoothRewind_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "TogglePauseAll", _m_TogglePauseAll_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "TogglePause", _m_TogglePause_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IsTweening", _m_IsTweening_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "TotalPlayingTweens", _m_TotalPlayingTweens_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "PlayingTweens", _m_PlayingTweens_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "PausedTweens", _m_PausedTweens_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "TweensById", _m_TweensById_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "TweensByTarget", _m_TweensByTarget_xlua_st_); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Version", DG.Tweening.DOTween.Version); + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "logBehaviour", _g_get_logBehaviour); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "debugStoreTargetId", _g_get_debugStoreTargetId); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "useSafeMode", _g_get_useSafeMode); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "nestedTweenFailureBehaviour", _g_get_nestedTweenFailureBehaviour); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "showUnityEditorReport", _g_get_showUnityEditorReport); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "timeScale", _g_get_timeScale); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "useSmoothDeltaTime", _g_get_useSmoothDeltaTime); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "maxSmoothUnscaledTime", _g_get_maxSmoothUnscaledTime); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "onWillLog", _g_get_onWillLog); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "drawGizmos", _g_get_drawGizmos); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "debugMode", _g_get_debugMode); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "defaultUpdateType", _g_get_defaultUpdateType); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "defaultTimeScaleIndependent", _g_get_defaultTimeScaleIndependent); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "defaultAutoPlay", _g_get_defaultAutoPlay); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "defaultAutoKill", _g_get_defaultAutoKill); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "defaultLoopType", _g_get_defaultLoopType); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "defaultRecyclable", _g_get_defaultRecyclable); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "defaultEaseType", _g_get_defaultEaseType); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "defaultEaseOvershootOrAmplitude", _g_get_defaultEaseOvershootOrAmplitude); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "defaultEasePeriod", _g_get_defaultEasePeriod); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "instance", _g_get_instance); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "logBehaviour", _s_set_logBehaviour); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "debugStoreTargetId", _s_set_debugStoreTargetId); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "useSafeMode", _s_set_useSafeMode); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "nestedTweenFailureBehaviour", _s_set_nestedTweenFailureBehaviour); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "showUnityEditorReport", _s_set_showUnityEditorReport); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "timeScale", _s_set_timeScale); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "useSmoothDeltaTime", _s_set_useSmoothDeltaTime); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "maxSmoothUnscaledTime", _s_set_maxSmoothUnscaledTime); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "onWillLog", _s_set_onWillLog); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "drawGizmos", _s_set_drawGizmos); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "debugMode", _s_set_debugMode); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "defaultUpdateType", _s_set_defaultUpdateType); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "defaultTimeScaleIndependent", _s_set_defaultTimeScaleIndependent); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "defaultAutoPlay", _s_set_defaultAutoPlay); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "defaultAutoKill", _s_set_defaultAutoKill); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "defaultLoopType", _s_set_defaultLoopType); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "defaultRecyclable", _s_set_defaultRecyclable); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "defaultEaseType", _s_set_defaultEaseType); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "defaultEaseOvershootOrAmplitude", _s_set_defaultEaseOvershootOrAmplitude); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "defaultEasePeriod", _s_set_defaultEasePeriod); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "instance", _s_set_instance); + + + 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 DG.Tweening.DOTween(); + 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 DG.Tweening.DOTween constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Init_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& translator.Assignable>(L, 3)) + { + System.Nullable _recycleAllByDefault;translator.Get(L, 1, out _recycleAllByDefault); + System.Nullable _useSafeMode;translator.Get(L, 2, out _useSafeMode); + System.Nullable _logBehaviour;translator.Get(L, 3, out _logBehaviour); + + var gen_ret = DG.Tweening.DOTween.Init( _recycleAllByDefault, _useSafeMode, _logBehaviour ); + translator.PushAny(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)) + { + System.Nullable _recycleAllByDefault;translator.Get(L, 1, out _recycleAllByDefault); + System.Nullable _useSafeMode;translator.Get(L, 2, out _useSafeMode); + + var gen_ret = DG.Tweening.DOTween.Init( _recycleAllByDefault, _useSafeMode ); + translator.PushAny(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable>(L, 1)) + { + System.Nullable _recycleAllByDefault;translator.Get(L, 1, out _recycleAllByDefault); + + var gen_ret = DG.Tweening.DOTween.Init( _recycleAllByDefault ); + translator.PushAny(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 0) + { + + var gen_ret = DG.Tweening.DOTween.Init( ); + translator.PushAny(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 DG.Tweening.DOTween.Init!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTweensCapacity_xlua_st_(RealStatePtr L) + { + try { + + + + + { + int _tweenersCapacity = LuaAPI.xlua_tointeger(L, 1); + int _sequencesCapacity = LuaAPI.xlua_tointeger(L, 2); + + DG.Tweening.DOTween.SetTweensCapacity( _tweenersCapacity, _sequencesCapacity ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Clear_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)) + { + bool _destroy = LuaAPI.lua_toboolean(L, 1); + + DG.Tweening.DOTween.Clear( _destroy ); + + + + return 0; + } + if(gen_param_count == 0) + { + + DG.Tweening.DOTween.Clear( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to DG.Tweening.DOTween.Clear!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearCachedTweens_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + DG.Tweening.DOTween.ClearCachedTweens( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Validate_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = DG.Tweening.DOTween.Validate( ); + 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_ManualUpdate_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _deltaTime = (float)LuaAPI.lua_tonumber(L, 1); + float _unscaledDeltaTime = (float)LuaAPI.lua_tonumber(L, 2); + + DG.Tweening.DOTween.ManualUpdate( _deltaTime, _unscaledDeltaTime ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_To_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable>(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 1); + float _startValue = (float)LuaAPI.lua_tonumber(L, 2); + float _endValue = (float)LuaAPI.lua_tonumber(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = DG.Tweening.DOTween.To( _setter, _startValue, _endValue, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + float _endValue = (float)LuaAPI.lua_tonumber(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = DG.Tweening.DOTween.To( _getter, _setter, _endValue, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + double _endValue = LuaAPI.lua_tonumber(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = DG.Tweening.DOTween.To( _getter, _setter, _endValue, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + int _endValue = LuaAPI.xlua_tointeger(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = DG.Tweening.DOTween.To( _getter, _setter, _endValue, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + uint _endValue = LuaAPI.xlua_touint(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = DG.Tweening.DOTween.To( _getter, _setter, _endValue, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) || LuaAPI.lua_isint64(L, 3))&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + long _endValue = LuaAPI.lua_toint64(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = DG.Tweening.DOTween.To( _getter, _setter, _endValue, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) || LuaAPI.lua_isuint64(L, 3))&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + ulong _endValue = LuaAPI.lua_touint64(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = DG.Tweening.DOTween.To( _getter, _setter, _endValue, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + string _endValue = LuaAPI.lua_tostring(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = DG.Tweening.DOTween.To( _getter, _setter, _endValue, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + UnityEngine.Vector2 _endValue;translator.Get(L, 3, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = DG.Tweening.DOTween.To( _getter, _setter, _endValue, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + UnityEngine.Vector3 _endValue;translator.Get(L, 3, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = DG.Tweening.DOTween.To( _getter, _setter, _endValue, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + UnityEngine.Vector4 _endValue;translator.Get(L, 3, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = DG.Tweening.DOTween.To( _getter, _setter, _endValue, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + UnityEngine.Vector3 _endValue;translator.Get(L, 3, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = DG.Tweening.DOTween.To( _getter, _setter, _endValue, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + UnityEngine.Color _endValue;translator.Get(L, 3, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = DG.Tweening.DOTween.To( _getter, _setter, _endValue, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + UnityEngine.Rect _endValue;translator.Get(L, 3, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = DG.Tweening.DOTween.To( _getter, _setter, _endValue, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + UnityEngine.RectOffset _endValue = (UnityEngine.RectOffset)translator.GetObject(L, 3, typeof(UnityEngine.RectOffset)); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = DG.Tweening.DOTween.To( _getter, _setter, _endValue, _duration ); + 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 DG.Tweening.DOTween.To!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToAxis_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 5&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + float _endValue = (float)LuaAPI.lua_tonumber(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + DG.Tweening.AxisConstraint _axisConstraint;translator.Get(L, 5, out _axisConstraint); + + var gen_ret = DG.Tweening.DOTween.ToAxis( _getter, _setter, _endValue, _duration, _axisConstraint ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + float _endValue = (float)LuaAPI.lua_tonumber(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = DG.Tweening.DOTween.ToAxis( _getter, _setter, _endValue, _duration ); + 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 DG.Tweening.DOTween.ToAxis!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToAlpha_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + float _endValue = (float)LuaAPI.lua_tonumber(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = DG.Tweening.DOTween.ToAlpha( _getter, _setter, _endValue, _duration ); + 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_Punch_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 6&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + int _vibrato = LuaAPI.xlua_tointeger(L, 5); + float _elasticity = (float)LuaAPI.lua_tonumber(L, 6); + + var gen_ret = DG.Tweening.DOTween.Punch( _getter, _setter, _direction, _duration, _vibrato, _elasticity ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + int _vibrato = LuaAPI.xlua_tointeger(L, 5); + + var gen_ret = DG.Tweening.DOTween.Punch( _getter, _setter, _direction, _duration, _vibrato ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = DG.Tweening.DOTween.Punch( _getter, _setter, _direction, _duration ); + 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 DG.Tweening.DOTween.Punch!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Shake_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 8&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 7)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 8)) + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + float _strength = (float)LuaAPI.lua_tonumber(L, 4); + int _vibrato = LuaAPI.xlua_tointeger(L, 5); + float _randomness = (float)LuaAPI.lua_tonumber(L, 6); + bool _ignoreZAxis = LuaAPI.lua_toboolean(L, 7); + bool _fadeOut = LuaAPI.lua_toboolean(L, 8); + + var gen_ret = DG.Tweening.DOTween.Shake( _getter, _setter, _duration, _strength, _vibrato, _randomness, _ignoreZAxis, _fadeOut ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 7&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 7)) + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + float _strength = (float)LuaAPI.lua_tonumber(L, 4); + int _vibrato = LuaAPI.xlua_tointeger(L, 5); + float _randomness = (float)LuaAPI.lua_tonumber(L, 6); + bool _ignoreZAxis = LuaAPI.lua_toboolean(L, 7); + + var gen_ret = DG.Tweening.DOTween.Shake( _getter, _setter, _duration, _strength, _vibrato, _randomness, _ignoreZAxis ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + float _strength = (float)LuaAPI.lua_tonumber(L, 4); + int _vibrato = LuaAPI.xlua_tointeger(L, 5); + float _randomness = (float)LuaAPI.lua_tonumber(L, 6); + + var gen_ret = DG.Tweening.DOTween.Shake( _getter, _setter, _duration, _strength, _vibrato, _randomness ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + float _strength = (float)LuaAPI.lua_tonumber(L, 4); + int _vibrato = LuaAPI.xlua_tointeger(L, 5); + + var gen_ret = DG.Tweening.DOTween.Shake( _getter, _setter, _duration, _strength, _vibrato ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + float _strength = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = DG.Tweening.DOTween.Shake( _getter, _setter, _duration, _strength ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = DG.Tweening.DOTween.Shake( _getter, _setter, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 7&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 7)) + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Vector3 _strength;translator.Get(L, 4, out _strength); + int _vibrato = LuaAPI.xlua_tointeger(L, 5); + float _randomness = (float)LuaAPI.lua_tonumber(L, 6); + bool _fadeOut = LuaAPI.lua_toboolean(L, 7); + + var gen_ret = DG.Tweening.DOTween.Shake( _getter, _setter, _duration, _strength, _vibrato, _randomness, _fadeOut ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Vector3 _strength;translator.Get(L, 4, out _strength); + int _vibrato = LuaAPI.xlua_tointeger(L, 5); + float _randomness = (float)LuaAPI.lua_tonumber(L, 6); + + var gen_ret = DG.Tweening.DOTween.Shake( _getter, _setter, _duration, _strength, _vibrato, _randomness ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Vector3 _strength;translator.Get(L, 4, out _strength); + int _vibrato = LuaAPI.xlua_tointeger(L, 5); + + var gen_ret = DG.Tweening.DOTween.Shake( _getter, _setter, _duration, _strength, _vibrato ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Vector3 _strength;translator.Get(L, 4, out _strength); + + var gen_ret = DG.Tweening.DOTween.Shake( _getter, _setter, _duration, _strength ); + 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 DG.Tweening.DOTween.Shake!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToArray_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + DG.Tweening.Core.DOGetter _getter = translator.GetDelegate>(L, 1); + DG.Tweening.Core.DOSetter _setter = translator.GetDelegate>(L, 2); + UnityEngine.Vector3[] _endValues = (UnityEngine.Vector3[])translator.GetObject(L, 3, typeof(UnityEngine.Vector3[])); + float[] _durations = (float[])translator.GetObject(L, 4, typeof(float[])); + + var gen_ret = DG.Tweening.DOTween.ToArray( _getter, _setter, _endValues, _durations ); + 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_Sequence_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = DG.Tweening.DOTween.Sequence( ); + 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_CompleteAll_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)) + { + bool _withCallbacks = LuaAPI.lua_toboolean(L, 1); + + var gen_ret = DG.Tweening.DOTween.CompleteAll( _withCallbacks ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 0) + { + + var gen_ret = DG.Tweening.DOTween.CompleteAll( ); + LuaAPI.xlua_pushinteger(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 DG.Tweening.DOTween.CompleteAll!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Complete_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + object _targetOrId = translator.GetObject(L, 1, typeof(object)); + bool _withCallbacks = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = DG.Tweening.DOTween.Complete( _targetOrId, _withCallbacks ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _targetOrId = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = DG.Tweening.DOTween.Complete( _targetOrId ); + LuaAPI.xlua_pushinteger(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 DG.Tweening.DOTween.Complete!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FlipAll_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = DG.Tweening.DOTween.FlipAll( ); + 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_Flip_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + object _targetOrId = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = DG.Tweening.DOTween.Flip( _targetOrId ); + 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_GotoAll_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + float _to = (float)LuaAPI.lua_tonumber(L, 1); + bool _andPlay = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = DG.Tweening.DOTween.GotoAll( _to, _andPlay ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + float _to = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = DG.Tweening.DOTween.GotoAll( _to ); + LuaAPI.xlua_pushinteger(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 DG.Tweening.DOTween.GotoAll!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Goto_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + object _targetOrId = translator.GetObject(L, 1, typeof(object)); + float _to = (float)LuaAPI.lua_tonumber(L, 2); + bool _andPlay = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = DG.Tweening.DOTween.Goto( _targetOrId, _to, _andPlay ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + object _targetOrId = translator.GetObject(L, 1, typeof(object)); + float _to = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = DG.Tweening.DOTween.Goto( _targetOrId, _to ); + LuaAPI.xlua_pushinteger(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 DG.Tweening.DOTween.Goto!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_KillAll_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)) + { + bool _complete = LuaAPI.lua_toboolean(L, 1); + + var gen_ret = DG.Tweening.DOTween.KillAll( _complete ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 0) + { + + var gen_ret = DG.Tweening.DOTween.KillAll( ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count >= 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 2) || translator.Assignable(L, 2))) + { + bool _complete = LuaAPI.lua_toboolean(L, 1); + object[] _idsOrTargetsToExclude = translator.GetParams(L, 2); + + var gen_ret = DG.Tweening.DOTween.KillAll( _complete, _idsOrTargetsToExclude ); + LuaAPI.xlua_pushinteger(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 DG.Tweening.DOTween.KillAll!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Kill_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + object _targetOrId = translator.GetObject(L, 1, typeof(object)); + bool _complete = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = DG.Tweening.DOTween.Kill( _targetOrId, _complete ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _targetOrId = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = DG.Tweening.DOTween.Kill( _targetOrId ); + LuaAPI.xlua_pushinteger(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 DG.Tweening.DOTween.Kill!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PauseAll_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = DG.Tweening.DOTween.PauseAll( ); + 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_Pause_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + object _targetOrId = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = DG.Tweening.DOTween.Pause( _targetOrId ); + 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_PlayAll_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = DG.Tweening.DOTween.PlayAll( ); + 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_Play_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _targetOrId = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = DG.Tweening.DOTween.Play( _targetOrId ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + object _target = translator.GetObject(L, 1, typeof(object)); + object _id = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = DG.Tweening.DOTween.Play( _target, _id ); + LuaAPI.xlua_pushinteger(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 DG.Tweening.DOTween.Play!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PlayBackwardsAll_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = DG.Tweening.DOTween.PlayBackwardsAll( ); + 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_PlayBackwards_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _targetOrId = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = DG.Tweening.DOTween.PlayBackwards( _targetOrId ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + object _target = translator.GetObject(L, 1, typeof(object)); + object _id = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = DG.Tweening.DOTween.PlayBackwards( _target, _id ); + LuaAPI.xlua_pushinteger(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 DG.Tweening.DOTween.PlayBackwards!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PlayForwardAll_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = DG.Tweening.DOTween.PlayForwardAll( ); + 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_PlayForward_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _targetOrId = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = DG.Tweening.DOTween.PlayForward( _targetOrId ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + object _target = translator.GetObject(L, 1, typeof(object)); + object _id = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = DG.Tweening.DOTween.PlayForward( _target, _id ); + LuaAPI.xlua_pushinteger(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 DG.Tweening.DOTween.PlayForward!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RestartAll_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)) + { + bool _includeDelay = LuaAPI.lua_toboolean(L, 1); + + var gen_ret = DG.Tweening.DOTween.RestartAll( _includeDelay ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 0) + { + + var gen_ret = DG.Tweening.DOTween.RestartAll( ); + LuaAPI.xlua_pushinteger(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 DG.Tweening.DOTween.RestartAll!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Restart_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + object _targetOrId = translator.GetObject(L, 1, typeof(object)); + bool _includeDelay = LuaAPI.lua_toboolean(L, 2); + float _changeDelayTo = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = DG.Tweening.DOTween.Restart( _targetOrId, _includeDelay, _changeDelayTo ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + object _targetOrId = translator.GetObject(L, 1, typeof(object)); + bool _includeDelay = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = DG.Tweening.DOTween.Restart( _targetOrId, _includeDelay ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _targetOrId = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = DG.Tweening.DOTween.Restart( _targetOrId ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + object _target = translator.GetObject(L, 1, typeof(object)); + object _id = translator.GetObject(L, 2, typeof(object)); + bool _includeDelay = LuaAPI.lua_toboolean(L, 3); + float _changeDelayTo = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = DG.Tweening.DOTween.Restart( _target, _id, _includeDelay, _changeDelayTo ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + object _target = translator.GetObject(L, 1, typeof(object)); + object _id = translator.GetObject(L, 2, typeof(object)); + bool _includeDelay = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = DG.Tweening.DOTween.Restart( _target, _id, _includeDelay ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + object _target = translator.GetObject(L, 1, typeof(object)); + object _id = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = DG.Tweening.DOTween.Restart( _target, _id ); + LuaAPI.xlua_pushinteger(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 DG.Tweening.DOTween.Restart!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RewindAll_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)) + { + bool _includeDelay = LuaAPI.lua_toboolean(L, 1); + + var gen_ret = DG.Tweening.DOTween.RewindAll( _includeDelay ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 0) + { + + var gen_ret = DG.Tweening.DOTween.RewindAll( ); + LuaAPI.xlua_pushinteger(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 DG.Tweening.DOTween.RewindAll!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Rewind_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + object _targetOrId = translator.GetObject(L, 1, typeof(object)); + bool _includeDelay = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = DG.Tweening.DOTween.Rewind( _targetOrId, _includeDelay ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _targetOrId = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = DG.Tweening.DOTween.Rewind( _targetOrId ); + LuaAPI.xlua_pushinteger(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 DG.Tweening.DOTween.Rewind!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SmoothRewindAll_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = DG.Tweening.DOTween.SmoothRewindAll( ); + 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_SmoothRewind_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + object _targetOrId = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = DG.Tweening.DOTween.SmoothRewind( _targetOrId ); + 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_TogglePauseAll_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = DG.Tweening.DOTween.TogglePauseAll( ); + 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_TogglePause_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + object _targetOrId = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = DG.Tweening.DOTween.TogglePause( _targetOrId ); + 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_IsTweening_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + object _targetOrId = translator.GetObject(L, 1, typeof(object)); + bool _alsoCheckIfIsPlaying = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = DG.Tweening.DOTween.IsTweening( _targetOrId, _alsoCheckIfIsPlaying ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _targetOrId = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = DG.Tweening.DOTween.IsTweening( _targetOrId ); + LuaAPI.lua_pushboolean(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 DG.Tweening.DOTween.IsTweening!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TotalPlayingTweens_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = DG.Tweening.DOTween.TotalPlayingTweens( ); + 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_PlayingTweens_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable>(L, 1)) + { + System.Collections.Generic.List _fillableList = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + + var gen_ret = DG.Tweening.DOTween.PlayingTweens( _fillableList ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 0) + { + + var gen_ret = DG.Tweening.DOTween.PlayingTweens( ); + 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 DG.Tweening.DOTween.PlayingTweens!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PausedTweens_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable>(L, 1)) + { + System.Collections.Generic.List _fillableList = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + + var gen_ret = DG.Tweening.DOTween.PausedTweens( _fillableList ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 0) + { + + var gen_ret = DG.Tweening.DOTween.PausedTweens( ); + 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 DG.Tweening.DOTween.PausedTweens!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TweensById_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + object _id = translator.GetObject(L, 1, typeof(object)); + bool _playingOnly = LuaAPI.lua_toboolean(L, 2); + System.Collections.Generic.List _fillableList = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + var gen_ret = DG.Tweening.DOTween.TweensById( _id, _playingOnly, _fillableList ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + object _id = translator.GetObject(L, 1, typeof(object)); + bool _playingOnly = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = DG.Tweening.DOTween.TweensById( _id, _playingOnly ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _id = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = DG.Tweening.DOTween.TweensById( _id ); + 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 DG.Tweening.DOTween.TweensById!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TweensByTarget_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + object _target = translator.GetObject(L, 1, typeof(object)); + bool _playingOnly = LuaAPI.lua_toboolean(L, 2); + System.Collections.Generic.List _fillableList = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + var gen_ret = DG.Tweening.DOTween.TweensByTarget( _target, _playingOnly, _fillableList ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + object _target = translator.GetObject(L, 1, typeof(object)); + bool _playingOnly = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = DG.Tweening.DOTween.TweensByTarget( _target, _playingOnly ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _target = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = DG.Tweening.DOTween.TweensByTarget( _target ); + 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 DG.Tweening.DOTween.TweensByTarget!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_logBehaviour(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushDGTweeningLogBehaviour(L, DG.Tweening.DOTween.logBehaviour); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_debugStoreTargetId(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, DG.Tweening.DOTween.debugStoreTargetId); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_useSafeMode(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, DG.Tweening.DOTween.useSafeMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_nestedTweenFailureBehaviour(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, DG.Tweening.DOTween.nestedTweenFailureBehaviour); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_showUnityEditorReport(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, DG.Tweening.DOTween.showUnityEditorReport); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_timeScale(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, DG.Tweening.DOTween.timeScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_useSmoothDeltaTime(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, DG.Tweening.DOTween.useSmoothDeltaTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxSmoothUnscaledTime(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, DG.Tweening.DOTween.maxSmoothUnscaledTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onWillLog(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, DG.Tweening.DOTween.onWillLog); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_drawGizmos(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, DG.Tweening.DOTween.drawGizmos); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_debugMode(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, DG.Tweening.DOTween.debugMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_defaultUpdateType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushDGTweeningUpdateType(L, DG.Tweening.DOTween.defaultUpdateType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_defaultTimeScaleIndependent(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, DG.Tweening.DOTween.defaultTimeScaleIndependent); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_defaultAutoPlay(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushDGTweeningAutoPlay(L, DG.Tweening.DOTween.defaultAutoPlay); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_defaultAutoKill(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, DG.Tweening.DOTween.defaultAutoKill); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_defaultLoopType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushDGTweeningLoopType(L, DG.Tweening.DOTween.defaultLoopType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_defaultRecyclable(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, DG.Tweening.DOTween.defaultRecyclable); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_defaultEaseType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushDGTweeningEase(L, DG.Tweening.DOTween.defaultEaseType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_defaultEaseOvershootOrAmplitude(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, DG.Tweening.DOTween.defaultEaseOvershootOrAmplitude); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_defaultEasePeriod(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, DG.Tweening.DOTween.defaultEasePeriod); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_instance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, DG.Tweening.DOTween.instance); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_logBehaviour(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + DG.Tweening.LogBehaviour gen_value;translator.Get(L, 1, out gen_value); + DG.Tweening.DOTween.logBehaviour = 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_debugStoreTargetId(RealStatePtr L) + { + try { + + DG.Tweening.DOTween.debugStoreTargetId = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_useSafeMode(RealStatePtr L) + { + try { + + DG.Tweening.DOTween.useSafeMode = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_nestedTweenFailureBehaviour(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + DG.Tweening.Core.Enums.NestedTweenFailureBehaviour gen_value;translator.Get(L, 1, out gen_value); + DG.Tweening.DOTween.nestedTweenFailureBehaviour = 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_showUnityEditorReport(RealStatePtr L) + { + try { + + DG.Tweening.DOTween.showUnityEditorReport = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_timeScale(RealStatePtr L) + { + try { + + DG.Tweening.DOTween.timeScale = (float)LuaAPI.lua_tonumber(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_useSmoothDeltaTime(RealStatePtr L) + { + try { + + DG.Tweening.DOTween.useSmoothDeltaTime = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_maxSmoothUnscaledTime(RealStatePtr L) + { + try { + + DG.Tweening.DOTween.maxSmoothUnscaledTime = (float)LuaAPI.lua_tonumber(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_onWillLog(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + DG.Tweening.DOTween.onWillLog = translator.GetDelegate>(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_drawGizmos(RealStatePtr L) + { + try { + + DG.Tweening.DOTween.drawGizmos = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_debugMode(RealStatePtr L) + { + try { + + DG.Tweening.DOTween.debugMode = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_defaultUpdateType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + DG.Tweening.UpdateType gen_value;translator.Get(L, 1, out gen_value); + DG.Tweening.DOTween.defaultUpdateType = 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_defaultTimeScaleIndependent(RealStatePtr L) + { + try { + + DG.Tweening.DOTween.defaultTimeScaleIndependent = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_defaultAutoPlay(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + DG.Tweening.AutoPlay gen_value;translator.Get(L, 1, out gen_value); + DG.Tweening.DOTween.defaultAutoPlay = 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_defaultAutoKill(RealStatePtr L) + { + try { + + DG.Tweening.DOTween.defaultAutoKill = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_defaultLoopType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + DG.Tweening.LoopType gen_value;translator.Get(L, 1, out gen_value); + DG.Tweening.DOTween.defaultLoopType = 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_defaultRecyclable(RealStatePtr L) + { + try { + + DG.Tweening.DOTween.defaultRecyclable = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_defaultEaseType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + DG.Tweening.Ease gen_value;translator.Get(L, 1, out gen_value); + DG.Tweening.DOTween.defaultEaseType = 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_defaultEaseOvershootOrAmplitude(RealStatePtr L) + { + try { + + DG.Tweening.DOTween.defaultEaseOvershootOrAmplitude = (float)LuaAPI.lua_tonumber(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_defaultEasePeriod(RealStatePtr L) + { + try { + + DG.Tweening.DOTween.defaultEasePeriod = (float)LuaAPI.lua_tonumber(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_instance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + DG.Tweening.DOTween.instance = (DG.Tweening.Core.DOTweenComponent)translator.GetObject(L, 1, typeof(DG.Tweening.Core.DOTweenComponent)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/DG_Tweening_DOVirtualWrap.cs b/Assets/XLua/Gen/DG_Tweening_DOVirtualWrap.cs new file mode 100644 index 000000000..0f3e01514 --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_DOVirtualWrap.cs @@ -0,0 +1,224 @@ +#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 DGTweeningDOVirtualWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.DOVirtual); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 4, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Float", _m_Float_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "EasedValue", _m_EasedValue_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "DelayedCall", _m_DelayedCall_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "DG.Tweening.DOVirtual does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Float_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + float _from = (float)LuaAPI.lua_tonumber(L, 1); + float _to = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + DG.Tweening.TweenCallback _onVirtualUpdate = translator.GetDelegate>(L, 4); + + var gen_ret = DG.Tweening.DOVirtual.Float( _from, _to, _duration, _onVirtualUpdate ); + 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_EasedValue_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + float _from = (float)LuaAPI.lua_tonumber(L, 1); + float _to = (float)LuaAPI.lua_tonumber(L, 2); + float _lifetimePercentage = (float)LuaAPI.lua_tonumber(L, 3); + DG.Tweening.Ease _easeType;translator.Get(L, 4, out _easeType); + + var gen_ret = DG.Tweening.DOVirtual.EasedValue( _from, _to, _lifetimePercentage, _easeType ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + float _from = (float)LuaAPI.lua_tonumber(L, 1); + float _to = (float)LuaAPI.lua_tonumber(L, 2); + float _lifetimePercentage = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.AnimationCurve _easeCurve = (UnityEngine.AnimationCurve)translator.GetObject(L, 4, typeof(UnityEngine.AnimationCurve)); + + var gen_ret = DG.Tweening.DOVirtual.EasedValue( _from, _to, _lifetimePercentage, _easeCurve ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + float _from = (float)LuaAPI.lua_tonumber(L, 1); + float _to = (float)LuaAPI.lua_tonumber(L, 2); + float _lifetimePercentage = (float)LuaAPI.lua_tonumber(L, 3); + DG.Tweening.Ease _easeType;translator.Get(L, 4, out _easeType); + float _overshoot = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = DG.Tweening.DOVirtual.EasedValue( _from, _to, _lifetimePercentage, _easeType, _overshoot ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + float _from = (float)LuaAPI.lua_tonumber(L, 1); + float _to = (float)LuaAPI.lua_tonumber(L, 2); + float _lifetimePercentage = (float)LuaAPI.lua_tonumber(L, 3); + DG.Tweening.Ease _easeType;translator.Get(L, 4, out _easeType); + float _amplitude = (float)LuaAPI.lua_tonumber(L, 5); + float _period = (float)LuaAPI.lua_tonumber(L, 6); + + var gen_ret = DG.Tweening.DOVirtual.EasedValue( _from, _to, _lifetimePercentage, _easeType, _amplitude, _period ); + LuaAPI.lua_pushnumber(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 DG.Tweening.DOVirtual.EasedValue!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DelayedCall_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + float _delay = (float)LuaAPI.lua_tonumber(L, 1); + DG.Tweening.TweenCallback _callback = translator.GetDelegate(L, 2); + bool _ignoreTimeScale = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = DG.Tweening.DOVirtual.DelayedCall( _delay, _callback, _ignoreTimeScale ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + float _delay = (float)LuaAPI.lua_tonumber(L, 1); + DG.Tweening.TweenCallback _callback = translator.GetDelegate(L, 2); + + var gen_ret = DG.Tweening.DOVirtual.DelayedCall( _delay, _callback ); + 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 DG.Tweening.DOVirtual.DelayedCall!"); + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/DG_Tweening_EaseFactoryWrap.cs b/Assets/XLua/Gen/DG_Tweening_EaseFactoryWrap.cs new file mode 100644 index 000000000..07409f456 --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_EaseFactoryWrap.cs @@ -0,0 +1,152 @@ +#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 DGTweeningEaseFactoryWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.EaseFactory); + 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, "StopMotion", _m_StopMotion_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 DG.Tweening.EaseFactory(); + 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 DG.Tweening.EaseFactory constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_StopMotion_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable>(L, 2)) + { + int _motionFps = LuaAPI.xlua_tointeger(L, 1); + System.Nullable _ease;translator.Get(L, 2, out _ease); + + var gen_ret = DG.Tweening.EaseFactory.StopMotion( _motionFps, _ease ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _motionFps = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = DG.Tweening.EaseFactory.StopMotion( _motionFps ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + int _motionFps = LuaAPI.xlua_tointeger(L, 1); + UnityEngine.AnimationCurve _animCurve = (UnityEngine.AnimationCurve)translator.GetObject(L, 2, typeof(UnityEngine.AnimationCurve)); + + var gen_ret = DG.Tweening.EaseFactory.StopMotion( _motionFps, _animCurve ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + int _motionFps = LuaAPI.xlua_tointeger(L, 1); + DG.Tweening.EaseFunction _customEase = translator.GetDelegate(L, 2); + + var gen_ret = DG.Tweening.EaseFactory.StopMotion( _motionFps, _customEase ); + 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 DG.Tweening.EaseFactory.StopMotion!"); + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/DG_Tweening_SequenceWrap.cs b/Assets/XLua/Gen/DG_Tweening_SequenceWrap.cs new file mode 100644 index 000000000..a1a1c8c6c --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_SequenceWrap.cs @@ -0,0 +1,1250 @@ +#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; +using DG.Tweening; + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class DGTweeningSequenceWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.Sequence); + Utils.BeginObjectRegister(type, L, translator, 0, 32, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Pause", _m_Pause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Play", _m_Play); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAutoKill", _m_SetAutoKill); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetId", _m_SetId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLink", _m_SetLink); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTarget", _m_SetTarget); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLoops", _m_SetLoops); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetEase", _m_SetEase); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRecyclable", _m_SetRecyclable); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetUpdate", _m_SetUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnStart", _m_OnStart); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPlay", _m_OnPlay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPause", _m_OnPause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRewind", _m_OnRewind); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnUpdate", _m_OnUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnStepComplete", _m_OnStepComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnComplete", _m_OnComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnKill", _m_OnKill); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnWaypointChange", _m_OnWaypointChange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAs", _m_SetAs); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Append", _m_Append); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Prepend", _m_Prepend); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Join", _m_Join); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Insert", _m_Insert); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AppendInterval", _m_AppendInterval); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PrependInterval", _m_PrependInterval); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AppendCallback", _m_AppendCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PrependCallback", _m_PrependCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InsertCallback", _m_InsertCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetDelay", _m_SetDelay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRelative", _m_SetRelative); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSpeedBased", _m_SetSpeedBased); + + + + + + 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, "DG.Tweening.Sequence does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Pause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Pause( ); + 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_Play(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Play( ); + 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_SetAutoKill(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetAutoKill( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _autoKillOnCompletion = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetAutoKill( _autoKillOnCompletion ); + 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 DG.Tweening.Sequence.SetAutoKill!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _intId = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.SetId( _intId ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _objectId = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.SetId( _objectId ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _stringId = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.SetId( _stringId ); + 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 DG.Tweening.Sequence.SetId!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLink(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.GameObject _gameObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + var gen_ret = gen_to_be_invoked.SetLink( _gameObject ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.GameObject _gameObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + DG.Tweening.LinkBehaviour _behaviour;translator.Get(L, 3, out _behaviour); + + var gen_ret = gen_to_be_invoked.SetLink( _gameObject, _behaviour ); + 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 DG.Tweening.Sequence.SetLink!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTarget(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + + { + object _target = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.SetTarget( _target ); + 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_SetLoops(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _loops = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.SetLoops( _loops ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _loops = LuaAPI.xlua_tointeger(L, 2); + DG.Tweening.LoopType _loopType;translator.Get(L, 3, out _loopType); + + var gen_ret = gen_to_be_invoked.SetLoops( _loops, _loopType ); + 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 DG.Tweening.Sequence.SetLoops!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetEase(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + + var gen_ret = gen_to_be_invoked.SetEase( _ease ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.AnimationCurve _animCurve = (UnityEngine.AnimationCurve)translator.GetObject(L, 2, typeof(UnityEngine.AnimationCurve)); + + var gen_ret = gen_to_be_invoked.SetEase( _animCurve ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.EaseFunction _customEase = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.SetEase( _customEase ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + float _overshoot = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.SetEase( _ease, _overshoot ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + float _amplitude = (float)LuaAPI.lua_tonumber(L, 3); + float _period = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.SetEase( _ease, _amplitude, _period ); + 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 DG.Tweening.Sequence.SetEase!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRecyclable(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetRecyclable( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _recyclable = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetRecyclable( _recyclable ); + 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 DG.Tweening.Sequence.SetRecyclable!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isIndependentUpdate = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetUpdate( _isIndependentUpdate ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.UpdateType _updateType;translator.Get(L, 2, out _updateType); + + var gen_ret = gen_to_be_invoked.SetUpdate( _updateType ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.UpdateType _updateType;translator.Get(L, 2, out _updateType); + bool _isIndependentUpdate = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.SetUpdate( _updateType, _isIndependentUpdate ); + 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 DG.Tweening.Sequence.SetUpdate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnStart(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnStart( _action ); + 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_OnPlay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnPlay( _action ); + 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_OnPause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnPause( _action ); + 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_OnRewind(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnRewind( _action ); + 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_OnUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnUpdate( _action ); + 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_OnStepComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnStepComplete( _action ); + 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_OnComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnComplete( _action ); + 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_OnKill(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnKill( _action ); + 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_OnWaypointChange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.OnWaypointChange( _action ); + 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_SetAs(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.Tween _asTween = (DG.Tweening.Tween)translator.GetObject(L, 2, typeof(DG.Tweening.Tween)); + + var gen_ret = gen_to_be_invoked.SetAs( _asTween ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.TweenParams _tweenParams = (DG.Tweening.TweenParams)translator.GetObject(L, 2, typeof(DG.Tweening.TweenParams)); + + var gen_ret = gen_to_be_invoked.SetAs( _tweenParams ); + 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 DG.Tweening.Sequence.SetAs!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Append(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.Tween _t = (DG.Tweening.Tween)translator.GetObject(L, 2, typeof(DG.Tweening.Tween)); + + var gen_ret = gen_to_be_invoked.Append( _t ); + 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_Prepend(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.Tween _t = (DG.Tweening.Tween)translator.GetObject(L, 2, typeof(DG.Tweening.Tween)); + + var gen_ret = gen_to_be_invoked.Prepend( _t ); + 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_Join(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.Tween _t = (DG.Tweening.Tween)translator.GetObject(L, 2, typeof(DG.Tweening.Tween)); + + var gen_ret = gen_to_be_invoked.Join( _t ); + 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_Insert(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + + { + float _atPosition = (float)LuaAPI.lua_tonumber(L, 2); + DG.Tweening.Tween _t = (DG.Tweening.Tween)translator.GetObject(L, 3, typeof(DG.Tweening.Tween)); + + var gen_ret = gen_to_be_invoked.Insert( _atPosition, _t ); + 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_AppendInterval(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + + { + float _interval = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.AppendInterval( _interval ); + 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_PrependInterval(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + + { + float _interval = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.PrependInterval( _interval ); + 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_AppendCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _callback = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.AppendCallback( _callback ); + 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_PrependCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _callback = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.PrependCallback( _callback ); + 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_InsertCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + + { + float _atPosition = (float)LuaAPI.lua_tonumber(L, 2); + DG.Tweening.TweenCallback _callback = translator.GetDelegate(L, 3); + + var gen_ret = gen_to_be_invoked.InsertCallback( _atPosition, _callback ); + 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_SetDelay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _delay = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.SetDelay( _delay ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + float _delay = (float)LuaAPI.lua_tonumber(L, 2); + bool _asPrependedIntervalIfSequence = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.SetDelay( _delay, _asPrependedIntervalIfSequence ); + 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 DG.Tweening.Sequence.SetDelay!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRelative(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetRelative( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isRelative = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetRelative( _isRelative ); + 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 DG.Tweening.Sequence.SetRelative!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSpeedBased(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Sequence gen_to_be_invoked = (DG.Tweening.Sequence)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetSpeedBased( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isSpeedBased = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetSpeedBased( _isSpeedBased ); + 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 DG.Tweening.Sequence.SetSpeedBased!"); + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/DG_Tweening_ShortcutExtensionsWrap.cs b/Assets/XLua/Gen/DG_Tweening_ShortcutExtensionsWrap.cs new file mode 100644 index 000000000..1b824f2f1 --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_ShortcutExtensionsWrap.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 DGTweeningShortcutExtensionsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.ShortcutExtensions); + 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, "DG.Tweening.ShortcutExtensions does not have a constructor!"); + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/DG_Tweening_TweenExtensionsWrap.cs b/Assets/XLua/Gen/DG_Tweening_TweenExtensionsWrap.cs new file mode 100644 index 000000000..e16ae09b2 --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_TweenExtensionsWrap.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 DGTweeningTweenExtensionsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.TweenExtensions); + 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, "DG.Tweening.TweenExtensions does not have a constructor!"); + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/DG_Tweening_TweenParamsWrap.cs b/Assets/XLua/Gen/DG_Tweening_TweenParamsWrap.cs new file mode 100644 index 000000000..645ae5543 --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_TweenParamsWrap.cs @@ -0,0 +1,804 @@ +#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 DGTweeningTweenParamsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.TweenParams); + Utils.BeginObjectRegister(type, L, translator, 0, 19, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAutoKill", _m_SetAutoKill); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetId", _m_SetId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTarget", _m_SetTarget); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLoops", _m_SetLoops); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetEase", _m_SetEase); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRecyclable", _m_SetRecyclable); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetUpdate", _m_SetUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnStart", _m_OnStart); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPlay", _m_OnPlay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRewind", _m_OnRewind); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnUpdate", _m_OnUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnStepComplete", _m_OnStepComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnComplete", _m_OnComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnKill", _m_OnKill); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnWaypointChange", _m_OnWaypointChange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetDelay", _m_SetDelay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRelative", _m_SetRelative); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSpeedBased", _m_SetSpeedBased); + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Params", DG.Tweening.TweenParams.Params); + + + + + 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 DG.Tweening.TweenParams(); + 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 DG.Tweening.TweenParams constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Clear(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.TweenParams gen_to_be_invoked = (DG.Tweening.TweenParams)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Clear( ); + 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_SetAutoKill(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.TweenParams gen_to_be_invoked = (DG.Tweening.TweenParams)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _autoKillOnCompletion = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetAutoKill( _autoKillOnCompletion ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetAutoKill( ); + 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 DG.Tweening.TweenParams.SetAutoKill!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.TweenParams gen_to_be_invoked = (DG.Tweening.TweenParams)translator.FastGetCSObj(L, 1); + + + + { + object _id = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.SetId( _id ); + 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_SetTarget(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.TweenParams gen_to_be_invoked = (DG.Tweening.TweenParams)translator.FastGetCSObj(L, 1); + + + + { + object _target = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.SetTarget( _target ); + 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_SetLoops(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.TweenParams gen_to_be_invoked = (DG.Tweening.TweenParams)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _loops = LuaAPI.xlua_tointeger(L, 2); + System.Nullable _loopType;translator.Get(L, 3, out _loopType); + + var gen_ret = gen_to_be_invoked.SetLoops( _loops, _loopType ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _loops = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.SetLoops( _loops ); + 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 DG.Tweening.TweenParams.SetLoops!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetEase(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.TweenParams gen_to_be_invoked = (DG.Tweening.TweenParams)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.AnimationCurve _animCurve = (UnityEngine.AnimationCurve)translator.GetObject(L, 2, typeof(UnityEngine.AnimationCurve)); + + var gen_ret = gen_to_be_invoked.SetEase( _animCurve ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.EaseFunction _customEase = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.SetEase( _customEase ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable>(L, 3)&& translator.Assignable>(L, 4)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + System.Nullable _overshootOrAmplitude;translator.Get(L, 3, out _overshootOrAmplitude); + System.Nullable _period;translator.Get(L, 4, out _period); + + var gen_ret = gen_to_be_invoked.SetEase( _ease, _overshootOrAmplitude, _period ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable>(L, 3)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + System.Nullable _overshootOrAmplitude;translator.Get(L, 3, out _overshootOrAmplitude); + + var gen_ret = gen_to_be_invoked.SetEase( _ease, _overshootOrAmplitude ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + + var gen_ret = gen_to_be_invoked.SetEase( _ease ); + 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 DG.Tweening.TweenParams.SetEase!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRecyclable(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.TweenParams gen_to_be_invoked = (DG.Tweening.TweenParams)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _recyclable = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetRecyclable( _recyclable ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetRecyclable( ); + 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 DG.Tweening.TweenParams.SetRecyclable!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.TweenParams gen_to_be_invoked = (DG.Tweening.TweenParams)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isIndependentUpdate = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetUpdate( _isIndependentUpdate ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.UpdateType _updateType;translator.Get(L, 2, out _updateType); + bool _isIndependentUpdate = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.SetUpdate( _updateType, _isIndependentUpdate ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.UpdateType _updateType;translator.Get(L, 2, out _updateType); + + var gen_ret = gen_to_be_invoked.SetUpdate( _updateType ); + 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 DG.Tweening.TweenParams.SetUpdate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnStart(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.TweenParams gen_to_be_invoked = (DG.Tweening.TweenParams)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnStart( _action ); + 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_OnPlay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.TweenParams gen_to_be_invoked = (DG.Tweening.TweenParams)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnPlay( _action ); + 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_OnRewind(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.TweenParams gen_to_be_invoked = (DG.Tweening.TweenParams)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnRewind( _action ); + 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_OnUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.TweenParams gen_to_be_invoked = (DG.Tweening.TweenParams)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnUpdate( _action ); + 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_OnStepComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.TweenParams gen_to_be_invoked = (DG.Tweening.TweenParams)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnStepComplete( _action ); + 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_OnComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.TweenParams gen_to_be_invoked = (DG.Tweening.TweenParams)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnComplete( _action ); + 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_OnKill(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.TweenParams gen_to_be_invoked = (DG.Tweening.TweenParams)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnKill( _action ); + 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_OnWaypointChange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.TweenParams gen_to_be_invoked = (DG.Tweening.TweenParams)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.OnWaypointChange( _action ); + 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_SetDelay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.TweenParams gen_to_be_invoked = (DG.Tweening.TweenParams)translator.FastGetCSObj(L, 1); + + + + { + float _delay = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.SetDelay( _delay ); + 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_SetRelative(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.TweenParams gen_to_be_invoked = (DG.Tweening.TweenParams)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isRelative = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetRelative( _isRelative ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetRelative( ); + 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 DG.Tweening.TweenParams.SetRelative!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSpeedBased(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.TweenParams gen_to_be_invoked = (DG.Tweening.TweenParams)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isSpeedBased = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetSpeedBased( _isSpeedBased ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetSpeedBased( ); + 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 DG.Tweening.TweenParams.SetSpeedBased!"); + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/DG_Tweening_TweenSettingsExtensionsWrap.cs b/Assets/XLua/Gen/DG_Tweening_TweenSettingsExtensionsWrap.cs new file mode 100644 index 000000000..61a15d8d4 --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_TweenSettingsExtensionsWrap.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 DGTweeningTweenSettingsExtensionsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.TweenSettingsExtensions); + 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, "DG.Tweening.TweenSettingsExtensions does not have a constructor!"); + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/DG_Tweening_TweenWrap.cs b/Assets/XLua/Gen/DG_Tweening_TweenWrap.cs new file mode 100644 index 000000000..a6dfd7cb2 --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_TweenWrap.cs @@ -0,0 +1,3075 @@ +#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; +using BF;using DG.Tweening; + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class DGTweeningTweenWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.Tween); + Utils.BeginObjectRegister(type, L, translator, 0, 65, 23, 18); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetIntId", _m_SetIntId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "WaitForCompletion", _m_WaitForCompletion); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "WaitForRewind", _m_WaitForRewind); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "WaitForKill", _m_WaitForKill); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "WaitForElapsedLoops", _m_WaitForElapsedLoops); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "WaitForPosition", _m_WaitForPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "WaitForStart", _m_WaitForStart); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AsyncWaitForCompletion", _m_AsyncWaitForCompletion); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AsyncWaitForRewind", _m_AsyncWaitForRewind); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AsyncWaitForKill", _m_AsyncWaitForKill); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AsyncWaitForElapsedLoops", _m_AsyncWaitForElapsedLoops); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AsyncWaitForPosition", _m_AsyncWaitForPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AsyncWaitForStart", _m_AsyncWaitForStart); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Complete", _m_Complete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Flip", _m_Flip); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ForceInit", _m_ForceInit); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Goto", _m_Goto); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Kill", _m_Kill); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Pause", _m_Pause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Play", _m_Play); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PlayBackwards", _m_PlayBackwards); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PlayForward", _m_PlayForward); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Restart", _m_Restart); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Rewind", _m_Rewind); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SmoothRewind", _m_SmoothRewind); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TogglePause", _m_TogglePause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GotoWaypoint", _m_GotoWaypoint); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CompletedLoops", _m_CompletedLoops); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Delay", _m_Delay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ElapsedDelay", _m_ElapsedDelay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Duration", _m_Duration); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Elapsed", _m_Elapsed); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ElapsedPercentage", _m_ElapsedPercentage); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ElapsedDirectionalPercentage", _m_ElapsedDirectionalPercentage); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsActive", _m_IsActive); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsBackwards", _m_IsBackwards); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsComplete", _m_IsComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsInitialized", _m_IsInitialized); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsPlaying", _m_IsPlaying); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Loops", _m_Loops); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PathGetPoint", _m_PathGetPoint); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PathGetDrawPoints", _m_PathGetDrawPoints); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PathLength", _m_PathLength); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAutoKill", _m_SetAutoKill); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetId", _m_SetId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLink", _m_SetLink); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTarget", _m_SetTarget); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLoops", _m_SetLoops); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetEase", _m_SetEase); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRecyclable", _m_SetRecyclable); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetUpdate", _m_SetUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnStart", _m_OnStart); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPlay", _m_OnPlay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPause", _m_OnPause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRewind", _m_OnRewind); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnUpdate", _m_OnUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnStepComplete", _m_OnStepComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnComplete", _m_OnComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnKill", _m_OnKill); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnWaypointChange", _m_OnWaypointChange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAs", _m_SetAs); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetDelay", _m_SetDelay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRelative", _m_SetRelative); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSpeedBased", _m_SetSpeedBased); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOTimeScale", _m_DOTimeScale); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isRelative", _g_get_isRelative); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "active", _g_get_active); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fullPosition", _g_get_fullPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "hasLoops", _g_get_hasLoops); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "playedOnce", _g_get_playedOnce); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "position", _g_get_position); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "timeScale", _g_get_timeScale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isBackwards", _g_get_isBackwards); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "id", _g_get_id); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "stringId", _g_get_stringId); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "intId", _g_get_intId); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "target", _g_get_target); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onPlay", _g_get_onPlay); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onPause", _g_get_onPause); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onRewind", _g_get_onRewind); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onUpdate", _g_get_onUpdate); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onStepComplete", _g_get_onStepComplete); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onComplete", _g_get_onComplete); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onKill", _g_get_onKill); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onWaypointChange", _g_get_onWaypointChange); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "easeOvershootOrAmplitude", _g_get_easeOvershootOrAmplitude); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "easePeriod", _g_get_easePeriod); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "debugTargetId", _g_get_debugTargetId); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fullPosition", _s_set_fullPosition); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "timeScale", _s_set_timeScale); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "isBackwards", _s_set_isBackwards); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "id", _s_set_id); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "stringId", _s_set_stringId); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "intId", _s_set_intId); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "target", _s_set_target); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onPlay", _s_set_onPlay); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onPause", _s_set_onPause); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onRewind", _s_set_onRewind); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onUpdate", _s_set_onUpdate); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onStepComplete", _s_set_onStepComplete); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onComplete", _s_set_onComplete); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onKill", _s_set_onKill); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onWaypointChange", _s_set_onWaypointChange); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "easeOvershootOrAmplitude", _s_set_easeOvershootOrAmplitude); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "easePeriod", _s_set_easePeriod); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "debugTargetId", _s_set_debugTargetId); + + + 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, "DG.Tweening.Tween does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetIntId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + int _id = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetIntId( _id ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_WaitForCompletion(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.WaitForCompletion( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _returnCustomYieldInstruction = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.WaitForCompletion( _returnCustomYieldInstruction ); + 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 DG.Tweening.Tween.WaitForCompletion!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_WaitForRewind(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.WaitForRewind( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _returnCustomYieldInstruction = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.WaitForRewind( _returnCustomYieldInstruction ); + 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 DG.Tweening.Tween.WaitForRewind!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_WaitForKill(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.WaitForKill( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _returnCustomYieldInstruction = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.WaitForKill( _returnCustomYieldInstruction ); + 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 DG.Tweening.Tween.WaitForKill!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_WaitForElapsedLoops(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _elapsedLoops = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.WaitForElapsedLoops( _elapsedLoops ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + int _elapsedLoops = LuaAPI.xlua_tointeger(L, 2); + bool _returnCustomYieldInstruction = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.WaitForElapsedLoops( _elapsedLoops, _returnCustomYieldInstruction ); + 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 DG.Tweening.Tween.WaitForElapsedLoops!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_WaitForPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _position = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.WaitForPosition( _position ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + float _position = (float)LuaAPI.lua_tonumber(L, 2); + bool _returnCustomYieldInstruction = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.WaitForPosition( _position, _returnCustomYieldInstruction ); + 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 DG.Tweening.Tween.WaitForPosition!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_WaitForStart(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.WaitForStart( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _returnCustomYieldInstruction = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.WaitForStart( _returnCustomYieldInstruction ); + 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 DG.Tweening.Tween.WaitForStart!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AsyncWaitForCompletion(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.AsyncWaitForCompletion( ); + 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_AsyncWaitForRewind(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.AsyncWaitForRewind( ); + 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_AsyncWaitForKill(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.AsyncWaitForKill( ); + 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_AsyncWaitForElapsedLoops(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + int _elapsedLoops = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.AsyncWaitForElapsedLoops( _elapsedLoops ); + 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_AsyncWaitForPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + float _position = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.AsyncWaitForPosition( _position ); + 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_AsyncWaitForStart(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.AsyncWaitForStart( ); + 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_Complete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.Complete( ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _withCallbacks = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.Complete( _withCallbacks ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to DG.Tweening.Tween.Complete!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Flip(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Flip( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ForceInit(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ForceInit( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Goto(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + float _to = (float)LuaAPI.lua_tonumber(L, 2); + bool _andPlay = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.Goto( _to, _andPlay ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _to = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.Goto( _to ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to DG.Tweening.Tween.Goto!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Kill(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _complete = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.Kill( _complete ); + + + + return 0; + } + if(gen_param_count == 1) + { + + gen_to_be_invoked.Kill( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to DG.Tweening.Tween.Kill!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Pause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Pause( ); + 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_Play(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Play( ); + 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_PlayBackwards(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.PlayBackwards( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PlayForward(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.PlayForward( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Restart(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + bool _includeDelay = LuaAPI.lua_toboolean(L, 2); + float _changeDelayTo = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.Restart( _includeDelay, _changeDelayTo ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _includeDelay = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.Restart( _includeDelay ); + + + + return 0; + } + if(gen_param_count == 1) + { + + gen_to_be_invoked.Restart( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to DG.Tweening.Tween.Restart!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Rewind(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _includeDelay = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.Rewind( _includeDelay ); + + + + return 0; + } + if(gen_param_count == 1) + { + + gen_to_be_invoked.Rewind( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to DG.Tweening.Tween.Rewind!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SmoothRewind(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SmoothRewind( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TogglePause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.TogglePause( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GotoWaypoint(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + int _waypointIndex = LuaAPI.xlua_tointeger(L, 2); + bool _andPlay = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.GotoWaypoint( _waypointIndex, _andPlay ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _waypointIndex = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.GotoWaypoint( _waypointIndex ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to DG.Tweening.Tween.GotoWaypoint!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CompletedLoops(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.CompletedLoops( ); + 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_Delay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Delay( ); + LuaAPI.lua_pushnumber(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_ElapsedDelay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.ElapsedDelay( ); + LuaAPI.lua_pushnumber(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_Duration(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _includeLoops = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.Duration( _includeLoops ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.Duration( ); + LuaAPI.lua_pushnumber(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 DG.Tweening.Tween.Duration!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Elapsed(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _includeLoops = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.Elapsed( _includeLoops ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.Elapsed( ); + LuaAPI.lua_pushnumber(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 DG.Tweening.Tween.Elapsed!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ElapsedPercentage(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _includeLoops = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.ElapsedPercentage( _includeLoops ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.ElapsedPercentage( ); + LuaAPI.lua_pushnumber(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 DG.Tweening.Tween.ElapsedPercentage!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ElapsedDirectionalPercentage(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.ElapsedDirectionalPercentage( ); + LuaAPI.lua_pushnumber(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_IsActive(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsActive( ); + 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_IsBackwards(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsBackwards( ); + 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_IsComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsComplete( ); + 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_IsInitialized(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsInitialized( ); + 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_IsPlaying(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsPlaying( ); + 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_Loops(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Loops( ); + 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_PathGetPoint(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + float _pathPercentage = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.PathGetPoint( _pathPercentage ); + translator.PushUnityEngineVector3(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_PathGetDrawPoints(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _subdivisionsXSegment = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.PathGetDrawPoints( _subdivisionsXSegment ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.PathGetDrawPoints( ); + 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 DG.Tweening.Tween.PathGetDrawPoints!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PathLength(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.PathLength( ); + LuaAPI.lua_pushnumber(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_SetAutoKill(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetAutoKill( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _autoKillOnCompletion = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetAutoKill( _autoKillOnCompletion ); + 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 DG.Tweening.Tween.SetAutoKill!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _intId = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.SetId( _intId ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _objectId = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.SetId( _objectId ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _stringId = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.SetId( _stringId ); + 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 DG.Tweening.Tween.SetId!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLink(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.GameObject _gameObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + var gen_ret = gen_to_be_invoked.SetLink( _gameObject ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.GameObject _gameObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + DG.Tweening.LinkBehaviour _behaviour;translator.Get(L, 3, out _behaviour); + + var gen_ret = gen_to_be_invoked.SetLink( _gameObject, _behaviour ); + 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 DG.Tweening.Tween.SetLink!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTarget(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + object _target = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.SetTarget( _target ); + 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_SetLoops(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _loops = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.SetLoops( _loops ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _loops = LuaAPI.xlua_tointeger(L, 2); + DG.Tweening.LoopType _loopType;translator.Get(L, 3, out _loopType); + + var gen_ret = gen_to_be_invoked.SetLoops( _loops, _loopType ); + 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 DG.Tweening.Tween.SetLoops!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetEase(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + + var gen_ret = gen_to_be_invoked.SetEase( _ease ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.AnimationCurve _animCurve = (UnityEngine.AnimationCurve)translator.GetObject(L, 2, typeof(UnityEngine.AnimationCurve)); + + var gen_ret = gen_to_be_invoked.SetEase( _animCurve ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.EaseFunction _customEase = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.SetEase( _customEase ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + float _overshoot = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.SetEase( _ease, _overshoot ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + float _amplitude = (float)LuaAPI.lua_tonumber(L, 3); + float _period = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.SetEase( _ease, _amplitude, _period ); + 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 DG.Tweening.Tween.SetEase!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRecyclable(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetRecyclable( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _recyclable = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetRecyclable( _recyclable ); + 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 DG.Tweening.Tween.SetRecyclable!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isIndependentUpdate = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetUpdate( _isIndependentUpdate ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.UpdateType _updateType;translator.Get(L, 2, out _updateType); + + var gen_ret = gen_to_be_invoked.SetUpdate( _updateType ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.UpdateType _updateType;translator.Get(L, 2, out _updateType); + bool _isIndependentUpdate = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.SetUpdate( _updateType, _isIndependentUpdate ); + 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 DG.Tweening.Tween.SetUpdate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnStart(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnStart( _action ); + 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_OnPlay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnPlay( _action ); + 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_OnPause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnPause( _action ); + 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_OnRewind(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnRewind( _action ); + 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_OnUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnUpdate( _action ); + 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_OnStepComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnStepComplete( _action ); + 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_OnComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnComplete( _action ); + 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_OnKill(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnKill( _action ); + 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_OnWaypointChange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.OnWaypointChange( _action ); + 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_SetAs(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.Tween _asTween = (DG.Tweening.Tween)translator.GetObject(L, 2, typeof(DG.Tweening.Tween)); + + var gen_ret = gen_to_be_invoked.SetAs( _asTween ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.TweenParams _tweenParams = (DG.Tweening.TweenParams)translator.GetObject(L, 2, typeof(DG.Tweening.TweenParams)); + + var gen_ret = gen_to_be_invoked.SetAs( _tweenParams ); + 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 DG.Tweening.Tween.SetAs!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetDelay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _delay = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.SetDelay( _delay ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + float _delay = (float)LuaAPI.lua_tonumber(L, 2); + bool _asPrependedIntervalIfSequence = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.SetDelay( _delay, _asPrependedIntervalIfSequence ); + 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 DG.Tweening.Tween.SetDelay!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRelative(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetRelative( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isRelative = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetRelative( _isRelative ); + 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 DG.Tweening.Tween.SetRelative!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSpeedBased(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetSpeedBased( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isSpeedBased = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetSpeedBased( _isSpeedBased ); + 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 DG.Tweening.Tween.SetSpeedBased!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOTimeScale(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + + + + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOTimeScale( _endValue, _duration ); + 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_isRelative(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isRelative); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_active(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.active); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fullPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.fullPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_hasLoops(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hasLoops); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_playedOnce(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.playedOnce); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_position(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.position); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_timeScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.timeScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isBackwards(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isBackwards); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_id(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.id); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_stringId(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.stringId); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_intId(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.intId); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_target(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.target); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onPlay(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onPlay); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onPause(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onPause); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onRewind(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onRewind); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onUpdate(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onUpdate); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onStepComplete(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onStepComplete); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onComplete(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onComplete); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onKill(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onKill); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onWaypointChange(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onWaypointChange); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_easeOvershootOrAmplitude(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.easeOvershootOrAmplitude); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_easePeriod(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.easePeriod); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_debugTargetId(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.debugTargetId); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_fullPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.fullPosition = (float)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_timeScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.timeScale = (float)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_isBackwards(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.isBackwards = 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_id(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.id = translator.GetObject(L, 2, typeof(object)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_stringId(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.stringId = 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_intId(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.intId = 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_target(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.target = translator.GetObject(L, 2, typeof(object)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_onPlay(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onPlay = translator.GetDelegate(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_onPause(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onPause = translator.GetDelegate(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_onRewind(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onRewind = translator.GetDelegate(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_onUpdate(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onUpdate = translator.GetDelegate(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_onStepComplete(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onStepComplete = translator.GetDelegate(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_onComplete(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onComplete = translator.GetDelegate(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_onKill(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onKill = translator.GetDelegate(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_onWaypointChange(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onWaypointChange = translator.GetDelegate>(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_easeOvershootOrAmplitude(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.easeOvershootOrAmplitude = (float)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_easePeriod(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.easePeriod = (float)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_debugTargetId(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + DG.Tweening.Tween gen_to_be_invoked = (DG.Tweening.Tween)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.debugTargetId = 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/DG_Tweening_TweenerWrap.cs b/Assets/XLua/Gen/DG_Tweening_TweenerWrap.cs new file mode 100644 index 000000000..525753890 --- /dev/null +++ b/Assets/XLua/Gen/DG_Tweening_TweenerWrap.cs @@ -0,0 +1,1187 @@ +#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; +using DG.Tweening; + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class DGTweeningTweenerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(DG.Tweening.Tweener); + Utils.BeginObjectRegister(type, L, translator, 0, 27, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ChangeStartValue", _m_ChangeStartValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ChangeEndValue", _m_ChangeEndValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ChangeValues", _m_ChangeValues); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Pause", _m_Pause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Play", _m_Play); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAutoKill", _m_SetAutoKill); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetId", _m_SetId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLink", _m_SetLink); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTarget", _m_SetTarget); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLoops", _m_SetLoops); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetEase", _m_SetEase); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRecyclable", _m_SetRecyclable); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetUpdate", _m_SetUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnStart", _m_OnStart); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPlay", _m_OnPlay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPause", _m_OnPause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRewind", _m_OnRewind); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnUpdate", _m_OnUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnStepComplete", _m_OnStepComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnComplete", _m_OnComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnKill", _m_OnKill); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnWaypointChange", _m_OnWaypointChange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAs", _m_SetAs); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "From", _m_From); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetDelay", _m_SetDelay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRelative", _m_SetRelative); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSpeedBased", _m_SetSpeedBased); + + + + + + 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, "DG.Tweening.Tweener does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ChangeStartValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tweener gen_to_be_invoked = (DG.Tweening.Tweener)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.ChangeStartValue( _newStartValue ); + 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 DG.Tweening.Tweener.ChangeStartValue!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ChangeEndValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tweener gen_to_be_invoked = (DG.Tweening.Tweener)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapStartValue = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration, _snapStartValue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _newEndValue = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.ChangeEndValue( _newEndValue ); + 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 DG.Tweening.Tweener.ChangeEndValue!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ChangeValues(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tweener gen_to_be_invoked = (DG.Tweening.Tweener)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + object _newEndValue = translator.GetObject(L, 3, typeof(object)); + float _newDuration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue, _newDuration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + object _newStartValue = translator.GetObject(L, 2, typeof(object)); + object _newEndValue = translator.GetObject(L, 3, typeof(object)); + + var gen_ret = gen_to_be_invoked.ChangeValues( _newStartValue, _newEndValue ); + 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 DG.Tweening.Tweener.ChangeValues!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Pause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tweener gen_to_be_invoked = (DG.Tweening.Tweener)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Pause( ); + 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_Play(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tweener gen_to_be_invoked = (DG.Tweening.Tweener)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Play( ); + 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_SetAutoKill(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tweener gen_to_be_invoked = (DG.Tweening.Tweener)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetAutoKill( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _autoKillOnCompletion = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetAutoKill( _autoKillOnCompletion ); + 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 DG.Tweening.Tweener.SetAutoKill!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tweener gen_to_be_invoked = (DG.Tweening.Tweener)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _intId = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.SetId( _intId ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _objectId = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.SetId( _objectId ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _stringId = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.SetId( _stringId ); + 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 DG.Tweening.Tweener.SetId!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLink(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tweener gen_to_be_invoked = (DG.Tweening.Tweener)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.GameObject _gameObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + var gen_ret = gen_to_be_invoked.SetLink( _gameObject ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.GameObject _gameObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + DG.Tweening.LinkBehaviour _behaviour;translator.Get(L, 3, out _behaviour); + + var gen_ret = gen_to_be_invoked.SetLink( _gameObject, _behaviour ); + 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 DG.Tweening.Tweener.SetLink!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTarget(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tweener gen_to_be_invoked = (DG.Tweening.Tweener)translator.FastGetCSObj(L, 1); + + + + { + object _target = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.SetTarget( _target ); + 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_SetLoops(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tweener gen_to_be_invoked = (DG.Tweening.Tweener)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _loops = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.SetLoops( _loops ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _loops = LuaAPI.xlua_tointeger(L, 2); + DG.Tweening.LoopType _loopType;translator.Get(L, 3, out _loopType); + + var gen_ret = gen_to_be_invoked.SetLoops( _loops, _loopType ); + 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 DG.Tweening.Tweener.SetLoops!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetEase(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tweener gen_to_be_invoked = (DG.Tweening.Tweener)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + + var gen_ret = gen_to_be_invoked.SetEase( _ease ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.AnimationCurve _animCurve = (UnityEngine.AnimationCurve)translator.GetObject(L, 2, typeof(UnityEngine.AnimationCurve)); + + var gen_ret = gen_to_be_invoked.SetEase( _animCurve ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.EaseFunction _customEase = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.SetEase( _customEase ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + float _overshoot = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.SetEase( _ease, _overshoot ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + DG.Tweening.Ease _ease;translator.Get(L, 2, out _ease); + float _amplitude = (float)LuaAPI.lua_tonumber(L, 3); + float _period = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.SetEase( _ease, _amplitude, _period ); + 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 DG.Tweening.Tweener.SetEase!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRecyclable(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tweener gen_to_be_invoked = (DG.Tweening.Tweener)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetRecyclable( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _recyclable = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetRecyclable( _recyclable ); + 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 DG.Tweening.Tweener.SetRecyclable!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tweener gen_to_be_invoked = (DG.Tweening.Tweener)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isIndependentUpdate = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetUpdate( _isIndependentUpdate ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.UpdateType _updateType;translator.Get(L, 2, out _updateType); + + var gen_ret = gen_to_be_invoked.SetUpdate( _updateType ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.UpdateType _updateType;translator.Get(L, 2, out _updateType); + bool _isIndependentUpdate = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.SetUpdate( _updateType, _isIndependentUpdate ); + 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 DG.Tweening.Tweener.SetUpdate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnStart(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tweener gen_to_be_invoked = (DG.Tweening.Tweener)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnStart( _action ); + 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_OnPlay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tweener gen_to_be_invoked = (DG.Tweening.Tweener)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnPlay( _action ); + 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_OnPause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tweener gen_to_be_invoked = (DG.Tweening.Tweener)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnPause( _action ); + 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_OnRewind(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tweener gen_to_be_invoked = (DG.Tweening.Tweener)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnRewind( _action ); + 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_OnUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tweener gen_to_be_invoked = (DG.Tweening.Tweener)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnUpdate( _action ); + 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_OnStepComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tweener gen_to_be_invoked = (DG.Tweening.Tweener)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnStepComplete( _action ); + 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_OnComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tweener gen_to_be_invoked = (DG.Tweening.Tweener)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnComplete( _action ); + 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_OnKill(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tweener gen_to_be_invoked = (DG.Tweening.Tweener)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate(L, 2); + + var gen_ret = gen_to_be_invoked.OnKill( _action ); + 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_OnWaypointChange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tweener gen_to_be_invoked = (DG.Tweening.Tweener)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.TweenCallback _action = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.OnWaypointChange( _action ); + 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_SetAs(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tweener gen_to_be_invoked = (DG.Tweening.Tweener)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.Tween _asTween = (DG.Tweening.Tween)translator.GetObject(L, 2, typeof(DG.Tweening.Tween)); + + var gen_ret = gen_to_be_invoked.SetAs( _asTween ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + DG.Tweening.TweenParams _tweenParams = (DG.Tweening.TweenParams)translator.GetObject(L, 2, typeof(DG.Tweening.TweenParams)); + + var gen_ret = gen_to_be_invoked.SetAs( _tweenParams ); + 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 DG.Tweening.Tweener.SetAs!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_From(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tweener gen_to_be_invoked = (DG.Tweening.Tweener)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.From( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isRelative = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.From( _isRelative ); + 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 DG.Tweening.Tweener.From!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetDelay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tweener gen_to_be_invoked = (DG.Tweening.Tweener)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _delay = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.SetDelay( _delay ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + float _delay = (float)LuaAPI.lua_tonumber(L, 2); + bool _asPrependedIntervalIfSequence = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.SetDelay( _delay, _asPrependedIntervalIfSequence ); + 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 DG.Tweening.Tweener.SetDelay!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRelative(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tweener gen_to_be_invoked = (DG.Tweening.Tweener)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetRelative( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isRelative = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetRelative( _isRelative ); + 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 DG.Tweening.Tweener.SetRelative!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSpeedBased(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + DG.Tweening.Tweener gen_to_be_invoked = (DG.Tweening.Tweener)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.SetSpeedBased( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isSpeedBased = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.SetSpeedBased( _isSpeedBased ); + 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 DG.Tweening.Tweener.SetSpeedBased!"); + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/DelegatesGensBridge.cs b/Assets/XLua/Gen/DelegatesGensBridge.cs new file mode 100644 index 000000000..89b577bfe --- /dev/null +++ b/Assets/XLua/Gen/DelegatesGensBridge.cs @@ -0,0 +1,3866 @@ +#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 System; + + +namespace XLua +{ + public partial class DelegateBridge : DelegateBridgeBase + { + + public void __Gen_Delegate_Imp0(string p0, string p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.lua_pushstring(L, p0); + LuaAPI.lua_pushstring(L, p1); + + PCall(L, 2, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp1() + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + + PCall(L, 0, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp2(int p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.xlua_pushinteger(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp3(int p0, string p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.xlua_pushinteger(L, p0); + LuaAPI.lua_pushstring(L, p1); + + PCall(L, 2, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp4(bool p0, string p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.lua_pushboolean(L, p0); + LuaAPI.lua_pushstring(L, p1); + + PCall(L, 2, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp5(string p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.lua_pushstring(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp6(UnityEngine.Vector2 p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.PushUnityEngineVector2(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp7(UnityEngine.GameObject p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp8(int p0, int p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.xlua_pushinteger(L, p0); + LuaAPI.xlua_pushinteger(L, p1); + + PCall(L, 2, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp9(bool p0, int p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.lua_pushboolean(L, p0); + LuaAPI.xlua_pushinteger(L, p1); + + PCall(L, 2, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp10(bool p0, UnityEngine.Purchasing.Product[] p1, string p2) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + LuaAPI.lua_pushboolean(L, p0); + translator.Push(L, p1); + LuaAPI.lua_pushstring(L, p2); + + PCall(L, 3, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp11(bool p0, UnityEngine.Purchasing.Product p1, string p2) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + LuaAPI.lua_pushboolean(L, p0); + translator.Push(L, p1); + LuaAPI.lua_pushstring(L, p2); + + PCall(L, 3, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public UnityEngine.Color __Gen_Delegate_Imp12() + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + + PCall(L, 0, 1, errFunc); + + + UnityEngine.Color __gen_ret;translator.Get(L, errFunc + 1, out __gen_ret); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp13(UnityEngine.Color p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.PushUnityEngineColor(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public UnityEngine.Vector2 __Gen_Delegate_Imp14() + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + + PCall(L, 0, 1, errFunc); + + + UnityEngine.Vector2 __gen_ret;translator.Get(L, errFunc + 1, out __gen_ret); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp15(UnityEngine.Camera p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public bool __Gen_Delegate_Imp16(UnityEngine.LogType p0, object p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + translator.PushAny(L, p1); + + PCall(L, 2, 1, errFunc); + + + bool __gen_ret = LuaAPI.lua_toboolean(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public UnityEngine.Vector3 __Gen_Delegate_Imp17() + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + + PCall(L, 0, 1, errFunc); + + + UnityEngine.Vector3 __gen_ret;translator.Get(L, errFunc + 1, out __gen_ret); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp18(UnityEngine.Vector3 p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.PushUnityEngineVector3(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public UnityEngine.Quaternion __Gen_Delegate_Imp19() + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + + PCall(L, 0, 1, errFunc); + + + UnityEngine.Quaternion __gen_ret;translator.Get(L, errFunc + 1, out __gen_ret); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp20(UnityEngine.Quaternion p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.PushUnityEngineQuaternion(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public float __Gen_Delegate_Imp21() + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + + PCall(L, 0, 1, errFunc); + + + float __gen_ret = (float)LuaAPI.lua_tonumber(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp22(float p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.lua_pushnumber(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp23(BestHTTP.HTTPRequest p0, long p1, long p2) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + LuaAPI.lua_pushint64(L, p1); + LuaAPI.lua_pushint64(L, p2); + + PCall(L, 3, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public bool __Gen_Delegate_Imp24(BestHTTP.HTTPRequest p0, BestHTTP.HTTPResponse p1, byte[] p2, int p3) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + translator.Push(L, p1); + LuaAPI.lua_pushstring(L, p2); + LuaAPI.xlua_pushinteger(L, p3); + + PCall(L, 4, 1, errFunc); + + + bool __gen_ret = LuaAPI.lua_toboolean(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp25(BestHTTP.HTTPRequest p0, BestHTTP.HTTPResponse p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + translator.Push(L, p1); + + PCall(L, 2, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp26(string p0, string p1, System.Action p2) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + LuaAPI.lua_pushstring(L, p0); + LuaAPI.lua_pushstring(L, p1); + translator.Push(L, p2); + + PCall(L, 3, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp27(int p0, System.Action p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + LuaAPI.xlua_pushinteger(L, p0); + translator.Push(L, p1); + + PCall(L, 2, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp28(int p0, System.Action p1, System.Action p2) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + LuaAPI.xlua_pushinteger(L, p0); + translator.Push(L, p1); + translator.Push(L, p2); + + PCall(L, 3, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp29(int p0, float p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.xlua_pushinteger(L, p0); + LuaAPI.lua_pushnumber(L, p1); + + PCall(L, 2, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp30(long p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.lua_pushint64(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public byte[] __Gen_Delegate_Imp31(ref string p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.lua_pushstring(L, p0); + + PCall(L, 1, 2, errFunc); + + p0 = LuaAPI.lua_tostring(L, errFunc + 2); + + byte[] __gen_ret = LuaAPI.lua_tobytes(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp32(bool p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.lua_pushboolean(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp33(int p0, uint p1, uint p2, byte[] p3) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.xlua_pushinteger(L, p0); + LuaAPI.xlua_pushuint(L, p1); + LuaAPI.xlua_pushuint(L, p2); + LuaAPI.lua_pushstring(L, p3); + + PCall(L, 4, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp34(int p0, int p1, string p2) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.xlua_pushinteger(L, p0); + LuaAPI.xlua_pushinteger(L, p1); + LuaAPI.lua_pushstring(L, p2); + + PCall(L, 3, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp35(UnityEngine.Texture2D p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp36(string p0, UnityEngine.Object p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + LuaAPI.lua_pushstring(L, p0); + translator.Push(L, p1); + + PCall(L, 2, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp37(BF.AssetBundleObject p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp38(uint p0, int p1, byte[] p2) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.xlua_pushuint(L, p0); + LuaAPI.xlua_pushinteger(L, p1); + LuaAPI.lua_pushstring(L, p2); + + PCall(L, 3, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp39(BF.ISocketChannel p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.PushAny(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public bool __Gen_Delegate_Imp40(string p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.lua_pushstring(L, p0); + + PCall(L, 1, 1, errFunc); + + + bool __gen_ret = LuaAPI.lua_toboolean(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public string __Gen_Delegate_Imp41() + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + + PCall(L, 0, 1, errFunc); + + + string __gen_ret = LuaAPI.lua_tostring(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp42(int p0, float p1, float p2) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.xlua_pushinteger(L, p0); + LuaAPI.lua_pushnumber(L, p1); + LuaAPI.lua_pushnumber(L, p2); + + PCall(L, 3, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp43(float p0, float p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.lua_pushnumber(L, p0); + LuaAPI.lua_pushnumber(L, p1); + + PCall(L, 2, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public int __Gen_Delegate_Imp44(int p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.xlua_pushinteger(L, p0); + + PCall(L, 1, 1, errFunc); + + + int __gen_ret = LuaAPI.xlua_tointeger(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public System.Collections.Generic.List __Gen_Delegate_Imp45(int p0, int p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + LuaAPI.xlua_pushinteger(L, p0); + LuaAPI.xlua_pushinteger(L, p1); + + PCall(L, 2, 1, errFunc); + + + System.Collections.Generic.List __gen_ret = (System.Collections.Generic.List)translator.GetObject(L, errFunc + 1, typeof(System.Collections.Generic.List)); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public UnityEngine.Texture2D __Gen_Delegate_Imp46() + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + + PCall(L, 0, 1, errFunc); + + + UnityEngine.Texture2D __gen_ret = (UnityEngine.Texture2D)translator.GetObject(L, errFunc + 1, typeof(UnityEngine.Texture2D)); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public System.Collections.Generic.List __Gen_Delegate_Imp47() + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + + PCall(L, 0, 1, errFunc); + + + System.Collections.Generic.List __gen_ret = (System.Collections.Generic.List)translator.GetObject(L, errFunc + 1, typeof(System.Collections.Generic.List)); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp48(IronSourceAdInfo p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp49(IronSourceError p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp50(IronSourceImpressionData p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp51(IronSourcePlacement p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp52(string p0, IronSourceError p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + LuaAPI.lua_pushstring(L, p0); + translator.Push(L, p1); + + PCall(L, 2, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp53(System.Collections.Generic.Dictionary p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp54(IronSourceError p0, IronSourceAdInfo p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + translator.Push(L, p1); + + PCall(L, 2, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp55(IronSourcePlacement p0, IronSourceAdInfo p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + translator.Push(L, p1); + + PCall(L, 2, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public string __Gen_Delegate_Imp56(System.DateTime p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 1, errFunc); + + + string __gen_ret = LuaAPI.lua_tostring(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp57(com.adjust.sdk.AdjustAttribution p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp58(com.adjust.sdk.AdjustEventSuccess p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp59(com.adjust.sdk.AdjustEventFailure p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp60(com.adjust.sdk.AdjustSessionSuccess p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp61(com.adjust.sdk.AdjustSessionFailure p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp62(int p0, string p1, bool p2) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.xlua_pushinteger(L, p0); + LuaAPI.lua_pushstring(L, p1); + LuaAPI.lua_pushboolean(L, p2); + + PCall(L, 3, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp63(Http.ResultInfo p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp64(System.IAsyncResult p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.PushAny(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp65(object p0, System.EventArgs p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.PushAny(L, p0); + translator.Push(L, p1); + + PCall(L, 2, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public bool __Gen_Delegate_Imp66(int p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.xlua_pushinteger(L, p0); + + PCall(L, 1, 1, errFunc); + + + bool __gen_ret = LuaAPI.lua_toboolean(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public int __Gen_Delegate_Imp67(int p0, int p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.xlua_pushinteger(L, p0); + LuaAPI.xlua_pushinteger(L, p1); + + PCall(L, 2, 1, errFunc); + + + int __gen_ret = LuaAPI.xlua_tointeger(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public bool __Gen_Delegate_Imp68(float p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.lua_pushnumber(L, p0); + + PCall(L, 1, 1, errFunc); + + + bool __gen_ret = LuaAPI.lua_toboolean(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public int __Gen_Delegate_Imp69(float p0, float p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.lua_pushnumber(L, p0); + LuaAPI.lua_pushnumber(L, p1); + + PCall(L, 2, 1, errFunc); + + + int __gen_ret = LuaAPI.xlua_tointeger(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public int __Gen_Delegate_Imp70(string p0, string p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.lua_pushstring(L, p0); + LuaAPI.lua_pushstring(L, p1); + + PCall(L, 2, 1, errFunc); + + + int __gen_ret = LuaAPI.xlua_tointeger(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public bool __Gen_Delegate_Imp71(TMPro.TMP_FontAsset p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 1, errFunc); + + + bool __gen_ret = LuaAPI.lua_toboolean(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp72(TMPro.TMP_FontAsset p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public int __Gen_Delegate_Imp73(TMPro.TMP_FontAsset p0, TMPro.TMP_FontAsset p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + translator.Push(L, p1); + + PCall(L, 2, 1, errFunc); + + + int __gen_ret = LuaAPI.xlua_tointeger(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public bool __Gen_Delegate_Imp74(UnityEngine.Camera p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 1, errFunc); + + + bool __gen_ret = LuaAPI.lua_toboolean(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public int __Gen_Delegate_Imp75(UnityEngine.Camera p0, UnityEngine.Camera p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + translator.Push(L, p1); + + PCall(L, 2, 1, errFunc); + + + int __gen_ret = LuaAPI.xlua_tointeger(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public bool __Gen_Delegate_Imp76(System.Collections.Generic.List p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 1, errFunc); + + + bool __gen_ret = LuaAPI.lua_toboolean(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp77(System.Collections.Generic.List p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public int __Gen_Delegate_Imp78(System.Collections.Generic.List p0, System.Collections.Generic.List p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + translator.Push(L, p1); + + PCall(L, 2, 1, errFunc); + + + int __gen_ret = LuaAPI.xlua_tointeger(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public bool __Gen_Delegate_Imp79(BF.BFFinger p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 1, errFunc); + + + bool __gen_ret = LuaAPI.lua_toboolean(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp80(BF.BFFinger p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public int __Gen_Delegate_Imp81(BF.BFFinger p0, BF.BFFinger p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + translator.Push(L, p1); + + PCall(L, 2, 1, errFunc); + + + int __gen_ret = LuaAPI.xlua_tointeger(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp82(UnityEngine.RectTransform p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp83(UnityEngine.Playables.PlayableDirector p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp84(string p0, bool p1, string p2) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.lua_pushstring(L, p0); + LuaAPI.lua_pushboolean(L, p1); + LuaAPI.lua_pushstring(L, p2); + + PCall(L, 3, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp85(string p0, string p1, UnityEngine.LogType p2) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + LuaAPI.lua_pushstring(L, p0); + LuaAPI.lua_pushstring(L, p1); + translator.Push(L, p2); + + PCall(L, 3, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public bool __Gen_Delegate_Imp86() + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + + PCall(L, 0, 1, errFunc); + + + bool __gen_ret = LuaAPI.lua_toboolean(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp87(float[] p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp88(UnityEngine.SceneManagement.Scene p0, UnityEngine.SceneManagement.LoadSceneMode p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + translator.Push(L, p1); + + PCall(L, 2, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp89(UnityEngine.SceneManagement.Scene p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp90(UnityEngine.SceneManagement.Scene p0, UnityEngine.SceneManagement.Scene p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + translator.Push(L, p1); + + PCall(L, 2, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp91(UnityEngine.AsyncOperation p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp92(UnityEngine.SpriteRenderer p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp93(UnityEngine.Video.VideoPlayer p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp94(UnityEngine.Video.VideoPlayer p0, string p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + LuaAPI.lua_pushstring(L, p1); + + PCall(L, 2, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp95(UnityEngine.Video.VideoPlayer p0, double p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + LuaAPI.lua_pushnumber(L, p1); + + PCall(L, 2, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp96(UnityEngine.Video.VideoPlayer p0, long p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + LuaAPI.lua_pushint64(L, p1); + + PCall(L, 2, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp97(UnityEngine.Font p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp98(UnityEngine.ReflectionProbe p0, UnityEngine.ReflectionProbe.ReflectionProbeEvent p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + translator.Push(L, p1); + + PCall(L, 2, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp99(UnityEngine.Cubemap p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp100(UnityEngine.Texture p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp101(UnityEngine.PhysicsScene p0, Unity.Collections.NativeArray p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + translator.Push(L, p1); + + PCall(L, 2, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public char __Gen_Delegate_Imp102(string p0, int p1, char p2) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.lua_pushstring(L, p0); + LuaAPI.xlua_pushinteger(L, p1); + LuaAPI.xlua_pushinteger(L, p2); + + PCall(L, 3, 1, errFunc); + + + char __gen_ret = (char)LuaAPI.xlua_tointeger(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp103(Spine.TrackEntry p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp104(Spine.TrackEntry p0, Spine.Event p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + translator.Push(L, p1); + + PCall(L, 2, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp105(UnityEngine.Mesh p0, UnityEngine.Material p1, UnityEngine.Texture p2) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + translator.Push(L, p1); + translator.Push(L, p2); + + PCall(L, 3, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp106(int p0, UnityEngine.Mesh[] p1, UnityEngine.Material[] p2, UnityEngine.Texture[] p3) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + LuaAPI.xlua_pushinteger(L, p0); + translator.Push(L, p1); + translator.Push(L, p2); + translator.Push(L, p3); + + PCall(L, 4, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp107(Spine.Unity.SkeletonGraphic p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp108(Spine.Unity.SkeletonRendererInstruction p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp109(Spine.Unity.ISkeletonAnimation p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.PushAny(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp110(Spine.Unity.MeshGeneratorBuffers p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp111(Spine.Unity.SkeletonRenderer p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp112(TMPro.TMP_TextInfo p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public TMPro.TMP_FontAsset __Gen_Delegate_Imp113(int p0, string p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + LuaAPI.xlua_pushinteger(L, p0); + LuaAPI.lua_pushstring(L, p1); + + PCall(L, 2, 1, errFunc); + + + TMPro.TMP_FontAsset __gen_ret = (TMPro.TMP_FontAsset)translator.GetObject(L, errFunc + 1, typeof(TMPro.TMP_FontAsset)); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public TMPro.TMP_SpriteAsset __Gen_Delegate_Imp114(int p0, string p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + LuaAPI.xlua_pushinteger(L, p0); + LuaAPI.lua_pushstring(L, p1); + + PCall(L, 2, 1, errFunc); + + + TMPro.TMP_SpriteAsset __gen_ret = (TMPro.TMP_SpriteAsset)translator.GetObject(L, errFunc + 1, typeof(TMPro.TMP_SpriteAsset)); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public double __Gen_Delegate_Imp115() + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + + PCall(L, 0, 1, errFunc); + + + double __gen_ret = LuaAPI.lua_tonumber(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp116(double p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.lua_pushnumber(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public int __Gen_Delegate_Imp117() + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + + PCall(L, 0, 1, errFunc); + + + int __gen_ret = LuaAPI.xlua_tointeger(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public uint __Gen_Delegate_Imp118() + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + + PCall(L, 0, 1, errFunc); + + + uint __gen_ret = LuaAPI.xlua_touint(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp119(uint p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.xlua_pushuint(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public long __Gen_Delegate_Imp120() + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + + PCall(L, 0, 1, errFunc); + + + long __gen_ret = LuaAPI.lua_toint64(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public ulong __Gen_Delegate_Imp121() + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + + PCall(L, 0, 1, errFunc); + + + ulong __gen_ret = LuaAPI.lua_touint64(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp122(ulong p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.lua_pushuint64(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public UnityEngine.Vector4 __Gen_Delegate_Imp123() + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + + PCall(L, 0, 1, errFunc); + + + UnityEngine.Vector4 __gen_ret;translator.Get(L, errFunc + 1, out __gen_ret); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp124(UnityEngine.Vector4 p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.PushUnityEngineVector4(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public UnityEngine.Rect __Gen_Delegate_Imp125() + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + + PCall(L, 0, 1, errFunc); + + + UnityEngine.Rect __gen_ret;translator.Get(L, errFunc + 1, out __gen_ret); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp126(UnityEngine.Rect p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public UnityEngine.RectOffset __Gen_Delegate_Imp127() + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + + PCall(L, 0, 1, errFunc); + + + UnityEngine.RectOffset __gen_ret = (UnityEngine.RectOffset)translator.GetObject(L, errFunc + 1, typeof(UnityEngine.RectOffset)); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp128(UnityEngine.RectOffset p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public float __Gen_Delegate_Imp129(float p0, float p1, float p2, float p3) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + + LuaAPI.lua_pushnumber(L, p0); + LuaAPI.lua_pushnumber(L, p1); + LuaAPI.lua_pushnumber(L, p2); + LuaAPI.lua_pushnumber(L, p3); + + PCall(L, 4, 1, errFunc); + + + float __gen_ret = (float)LuaAPI.lua_tonumber(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public bool __Gen_Delegate_Imp130(BestHTTP.HTTPRequest p0, System.Security.Cryptography.X509Certificates.X509Certificate p1, System.Security.Cryptography.X509Certificates.X509Chain p2) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + translator.Push(L, p1); + translator.Push(L, p2); + + PCall(L, 3, 1, errFunc); + + + bool __gen_ret = LuaAPI.lua_toboolean(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public bool __Gen_Delegate_Imp131(BestHTTP.HTTPRequest p0, BestHTTP.HTTPResponse p1, System.Uri p2) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + translator.Push(L, p1); + translator.Push(L, p2); + + PCall(L, 3, 1, errFunc); + + + bool __gen_ret = LuaAPI.lua_toboolean(L, errFunc + 1); + LuaAPI.lua_settop(L, errFunc - 1); + return __gen_ret; +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp132(BestHTTP.HTTPRequest p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp133(string p0, System.Collections.Generic.List p1) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + LuaAPI.lua_pushstring(L, p0); + translator.Push(L, p1); + + PCall(L, 2, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + public void __Gen_Delegate_Imp134(System.Collections.Generic.List p0) + { +#if THREAD_SAFE || HOTFIX_ENABLE + lock (luaEnv.luaEnvLock) + { +#endif + RealStatePtr L = luaEnv.rawL; + int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference); + ObjectTranslator translator = luaEnv.translator; + translator.Push(L, p0); + + PCall(L, 1, 0, errFunc); + + + + LuaAPI.lua_settop(L, errFunc - 1); + +#if THREAD_SAFE || HOTFIX_ENABLE + } +#endif + } + + + static DelegateBridge() + { + Gen_Flag = true; + } + + public override Delegate GetDelegateByType(Type type) + { + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp0); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp1); + } + + if (type == typeof(DG.Tweening.TweenCallback)) + { + return new DG.Tweening.TweenCallback(__Gen_Delegate_Imp1); + } + + if (type == typeof(UnityEngine.Application.LowMemoryCallback)) + { + return new UnityEngine.Application.LowMemoryCallback(__Gen_Delegate_Imp1); + } + + if (type == typeof(UnityEngine.Events.UnityAction)) + { + return new UnityEngine.Events.UnityAction(__Gen_Delegate_Imp1); + } + + if (type == typeof(UnityEngine.Canvas.WillRenderCanvases)) + { + return new UnityEngine.Canvas.WillRenderCanvases(__Gen_Delegate_Imp1); + } + + if (type == typeof(UnityEngine.Font.FontTextureRebuildCallback)) + { + return new UnityEngine.Font.FontTextureRebuildCallback(__Gen_Delegate_Imp1); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp2); + } + + if (type == typeof(DG.Tweening.TweenCallback)) + { + return new DG.Tweening.TweenCallback(__Gen_Delegate_Imp2); + } + + if (type == typeof(UnityEngine.AudioClip.PCMSetPositionCallback)) + { + return new UnityEngine.AudioClip.PCMSetPositionCallback(__Gen_Delegate_Imp2); + } + + if (type == typeof(UnityEngine.Events.UnityAction)) + { + return new UnityEngine.Events.UnityAction(__Gen_Delegate_Imp2); + } + + if (type == typeof(DG.Tweening.Core.DOSetter)) + { + return new DG.Tweening.Core.DOSetter(__Gen_Delegate_Imp2); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp3); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp4); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp5); + } + + if (type == typeof(UnityEngine.Events.UnityAction)) + { + return new UnityEngine.Events.UnityAction(__Gen_Delegate_Imp5); + } + + if (type == typeof(DG.Tweening.Core.DOSetter)) + { + return new DG.Tweening.Core.DOSetter(__Gen_Delegate_Imp5); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp6); + } + + if (type == typeof(DG.Tweening.Core.DOSetter)) + { + return new DG.Tweening.Core.DOSetter(__Gen_Delegate_Imp6); + } + + if (type == typeof(UnityEngine.Events.UnityAction)) + { + return new UnityEngine.Events.UnityAction(__Gen_Delegate_Imp6); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp7); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp8); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp9); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp10); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp11); + } + + if (type == typeof(DG.Tweening.Core.DOGetter)) + { + return new DG.Tweening.Core.DOGetter(__Gen_Delegate_Imp12); + } + + if (type == typeof(DG.Tweening.Core.DOSetter)) + { + return new DG.Tweening.Core.DOSetter(__Gen_Delegate_Imp13); + } + + if (type == typeof(DG.Tweening.Core.DOGetter)) + { + return new DG.Tweening.Core.DOGetter(__Gen_Delegate_Imp14); + } + + if (type == typeof(UnityEngine.Camera.CameraCallback)) + { + return new UnityEngine.Camera.CameraCallback(__Gen_Delegate_Imp15); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp15); + } + + if (type == typeof(System.Func)) + { + return new System.Func(__Gen_Delegate_Imp16); + } + + if (type == typeof(DG.Tweening.Core.DOGetter)) + { + return new DG.Tweening.Core.DOGetter(__Gen_Delegate_Imp17); + } + + if (type == typeof(DG.Tweening.Core.DOSetter)) + { + return new DG.Tweening.Core.DOSetter(__Gen_Delegate_Imp18); + } + + if (type == typeof(DG.Tweening.Core.DOGetter)) + { + return new DG.Tweening.Core.DOGetter(__Gen_Delegate_Imp19); + } + + if (type == typeof(DG.Tweening.Core.DOSetter)) + { + return new DG.Tweening.Core.DOSetter(__Gen_Delegate_Imp20); + } + + if (type == typeof(DG.Tweening.Core.DOGetter)) + { + return new DG.Tweening.Core.DOGetter(__Gen_Delegate_Imp21); + } + + if (type == typeof(DG.Tweening.Core.DOSetter)) + { + return new DG.Tweening.Core.DOSetter(__Gen_Delegate_Imp22); + } + + if (type == typeof(UnityEngine.Events.UnityAction)) + { + return new UnityEngine.Events.UnityAction(__Gen_Delegate_Imp22); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp22); + } + + if (type == typeof(DG.Tweening.TweenCallback)) + { + return new DG.Tweening.TweenCallback(__Gen_Delegate_Imp22); + } + + if (type == typeof(BestHTTP.OnUploadProgressDelegate)) + { + return new BestHTTP.OnUploadProgressDelegate(__Gen_Delegate_Imp23); + } + + if (type == typeof(BestHTTP.OnDownloadProgressDelegate)) + { + return new BestHTTP.OnDownloadProgressDelegate(__Gen_Delegate_Imp23); + } + + if (type == typeof(BestHTTP.OnStreamingDataDelegate)) + { + return new BestHTTP.OnStreamingDataDelegate(__Gen_Delegate_Imp24); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp25); + } + + if (type == typeof(BestHTTP.OnRequestFinishedDelegate)) + { + return new BestHTTP.OnRequestFinishedDelegate(__Gen_Delegate_Imp25); + } + + if (type == typeof(System.Action>)) + { + return new System.Action>(__Gen_Delegate_Imp26); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp27); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp28); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp29); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp30); + } + + if (type == typeof(UnityEngine.Events.UnityAction)) + { + return new UnityEngine.Events.UnityAction(__Gen_Delegate_Imp30); + } + + if (type == typeof(DG.Tweening.Core.DOSetter)) + { + return new DG.Tweening.Core.DOSetter(__Gen_Delegate_Imp30); + } + + if (type == typeof(XLua.LuaEnv.CustomLoader)) + { + return new XLua.LuaEnv.CustomLoader(__Gen_Delegate_Imp31); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp32); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp33); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp34); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp35); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp36); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp37); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp38); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp39); + } + + if (type == typeof(System.Func)) + { + return new System.Func(__Gen_Delegate_Imp40); + } + + if (type == typeof(System.Predicate)) + { + return new System.Predicate(__Gen_Delegate_Imp40); + } + + if (type == typeof(System.Func)) + { + return new System.Func(__Gen_Delegate_Imp41); + } + + if (type == typeof(DG.Tweening.Core.DOGetter)) + { + return new DG.Tweening.Core.DOGetter(__Gen_Delegate_Imp41); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp42); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp43); + } + + if (type == typeof(System.Func)) + { + return new System.Func(__Gen_Delegate_Imp44); + } + + if (type == typeof(System.Func>)) + { + return new System.Func>(__Gen_Delegate_Imp45); + } + + if (type == typeof(System.Func)) + { + return new System.Func(__Gen_Delegate_Imp46); + } + + if (type == typeof(System.Func>)) + { + return new System.Func>(__Gen_Delegate_Imp47); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp48); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp49); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp50); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp51); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp52); + } + + if (type == typeof(System.Action>)) + { + return new System.Action>(__Gen_Delegate_Imp53); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp54); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp55); + } + + if (type == typeof(System.Func)) + { + return new System.Func(__Gen_Delegate_Imp56); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp57); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp58); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp59); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp60); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp61); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp62); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp63); + } + + if (type == typeof(System.AsyncCallback)) + { + return new System.AsyncCallback(__Gen_Delegate_Imp64); + } + + if (type == typeof(System.EventHandler)) + { + return new System.EventHandler(__Gen_Delegate_Imp65); + } + + if (type == typeof(System.Predicate)) + { + return new System.Predicate(__Gen_Delegate_Imp66); + } + + if (type == typeof(System.Comparison)) + { + return new System.Comparison(__Gen_Delegate_Imp67); + } + + if (type == typeof(System.Predicate)) + { + return new System.Predicate(__Gen_Delegate_Imp68); + } + + if (type == typeof(System.Comparison)) + { + return new System.Comparison(__Gen_Delegate_Imp69); + } + + if (type == typeof(System.Comparison)) + { + return new System.Comparison(__Gen_Delegate_Imp70); + } + + if (type == typeof(System.Predicate)) + { + return new System.Predicate(__Gen_Delegate_Imp71); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp72); + } + + if (type == typeof(System.Comparison)) + { + return new System.Comparison(__Gen_Delegate_Imp73); + } + + if (type == typeof(System.Predicate)) + { + return new System.Predicate(__Gen_Delegate_Imp74); + } + + if (type == typeof(System.Comparison)) + { + return new System.Comparison(__Gen_Delegate_Imp75); + } + + if (type == typeof(System.Predicate>)) + { + return new System.Predicate>(__Gen_Delegate_Imp76); + } + + if (type == typeof(System.Action>)) + { + return new System.Action>(__Gen_Delegate_Imp77); + } + + if (type == typeof(System.Comparison>)) + { + return new System.Comparison>(__Gen_Delegate_Imp78); + } + + if (type == typeof(System.Predicate)) + { + return new System.Predicate(__Gen_Delegate_Imp79); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp80); + } + + if (type == typeof(System.Comparison)) + { + return new System.Comparison(__Gen_Delegate_Imp81); + } + + if (type == typeof(UnityEngine.RectTransform.ReapplyDrivenProperties)) + { + return new UnityEngine.RectTransform.ReapplyDrivenProperties(__Gen_Delegate_Imp82); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp83); + } + + if (type == typeof(UnityEngine.Application.AdvertisingIdentifierCallback)) + { + return new UnityEngine.Application.AdvertisingIdentifierCallback(__Gen_Delegate_Imp84); + } + + if (type == typeof(UnityEngine.Application.LogCallback)) + { + return new UnityEngine.Application.LogCallback(__Gen_Delegate_Imp85); + } + + if (type == typeof(System.Func)) + { + return new System.Func(__Gen_Delegate_Imp86); + } + + if (type == typeof(UnityEngine.AudioClip.PCMReaderCallback)) + { + return new UnityEngine.AudioClip.PCMReaderCallback(__Gen_Delegate_Imp87); + } + + if (type == typeof(UnityEngine.Events.UnityAction)) + { + return new UnityEngine.Events.UnityAction(__Gen_Delegate_Imp88); + } + + if (type == typeof(UnityEngine.Events.UnityAction)) + { + return new UnityEngine.Events.UnityAction(__Gen_Delegate_Imp89); + } + + if (type == typeof(UnityEngine.Events.UnityAction)) + { + return new UnityEngine.Events.UnityAction(__Gen_Delegate_Imp90); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp91); + } + + if (type == typeof(UnityEngine.Events.UnityAction)) + { + return new UnityEngine.Events.UnityAction(__Gen_Delegate_Imp92); + } + + if (type == typeof(UnityEngine.Video.VideoPlayer.EventHandler)) + { + return new UnityEngine.Video.VideoPlayer.EventHandler(__Gen_Delegate_Imp93); + } + + if (type == typeof(UnityEngine.Video.VideoPlayer.ErrorEventHandler)) + { + return new UnityEngine.Video.VideoPlayer.ErrorEventHandler(__Gen_Delegate_Imp94); + } + + if (type == typeof(UnityEngine.Video.VideoPlayer.TimeEventHandler)) + { + return new UnityEngine.Video.VideoPlayer.TimeEventHandler(__Gen_Delegate_Imp95); + } + + if (type == typeof(UnityEngine.Video.VideoPlayer.FrameReadyEventHandler)) + { + return new UnityEngine.Video.VideoPlayer.FrameReadyEventHandler(__Gen_Delegate_Imp96); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp97); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp98); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp99); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp100); + } + + if (type == typeof(System.Action>)) + { + return new System.Action>(__Gen_Delegate_Imp101); + } + + if (type == typeof(UnityEngine.UI.InputField.OnValidateInput)) + { + return new UnityEngine.UI.InputField.OnValidateInput(__Gen_Delegate_Imp102); + } + + if (type == typeof(TMPro.TMP_InputField.OnValidateInput)) + { + return new TMPro.TMP_InputField.OnValidateInput(__Gen_Delegate_Imp102); + } + + if (type == typeof(Spine.AnimationState.TrackEntryDelegate)) + { + return new Spine.AnimationState.TrackEntryDelegate(__Gen_Delegate_Imp103); + } + + if (type == typeof(Spine.AnimationState.TrackEntryEventDelegate)) + { + return new Spine.AnimationState.TrackEntryEventDelegate(__Gen_Delegate_Imp104); + } + + if (type == typeof(Spine.Unity.SkeletonGraphic.MeshAssignmentDelegateSingle)) + { + return new Spine.Unity.SkeletonGraphic.MeshAssignmentDelegateSingle(__Gen_Delegate_Imp105); + } + + if (type == typeof(Spine.Unity.SkeletonGraphic.MeshAssignmentDelegateMultiple)) + { + return new Spine.Unity.SkeletonGraphic.MeshAssignmentDelegateMultiple(__Gen_Delegate_Imp106); + } + + if (type == typeof(Spine.Unity.SkeletonGraphic.SkeletonRendererDelegate)) + { + return new Spine.Unity.SkeletonGraphic.SkeletonRendererDelegate(__Gen_Delegate_Imp107); + } + + if (type == typeof(Spine.Unity.SkeletonGraphic.InstructionDelegate)) + { + return new Spine.Unity.SkeletonGraphic.InstructionDelegate(__Gen_Delegate_Imp108); + } + + if (type == typeof(Spine.Unity.SkeletonRenderer.InstructionDelegate)) + { + return new Spine.Unity.SkeletonRenderer.InstructionDelegate(__Gen_Delegate_Imp108); + } + + if (type == typeof(Spine.Unity.ISkeletonAnimationDelegate)) + { + return new Spine.Unity.ISkeletonAnimationDelegate(__Gen_Delegate_Imp109); + } + + if (type == typeof(Spine.Unity.UpdateBonesDelegate)) + { + return new Spine.Unity.UpdateBonesDelegate(__Gen_Delegate_Imp109); + } + + if (type == typeof(Spine.Unity.MeshGeneratorDelegate)) + { + return new Spine.Unity.MeshGeneratorDelegate(__Gen_Delegate_Imp110); + } + + if (type == typeof(Spine.Unity.SkeletonRenderer.SkeletonRendererDelegate)) + { + return new Spine.Unity.SkeletonRenderer.SkeletonRendererDelegate(__Gen_Delegate_Imp111); + } + + if (type == typeof(System.Action)) + { + return new System.Action(__Gen_Delegate_Imp112); + } + + if (type == typeof(System.Func)) + { + return new System.Func(__Gen_Delegate_Imp113); + } + + if (type == typeof(System.Func)) + { + return new System.Func(__Gen_Delegate_Imp114); + } + + if (type == typeof(DG.Tweening.Core.DOGetter)) + { + return new DG.Tweening.Core.DOGetter(__Gen_Delegate_Imp115); + } + + if (type == typeof(DG.Tweening.Core.DOSetter)) + { + return new DG.Tweening.Core.DOSetter(__Gen_Delegate_Imp116); + } + + if (type == typeof(DG.Tweening.Core.DOGetter)) + { + return new DG.Tweening.Core.DOGetter(__Gen_Delegate_Imp117); + } + + if (type == typeof(DG.Tweening.Core.DOGetter)) + { + return new DG.Tweening.Core.DOGetter(__Gen_Delegate_Imp118); + } + + if (type == typeof(DG.Tweening.Core.DOSetter)) + { + return new DG.Tweening.Core.DOSetter(__Gen_Delegate_Imp119); + } + + if (type == typeof(DG.Tweening.Core.DOGetter)) + { + return new DG.Tweening.Core.DOGetter(__Gen_Delegate_Imp120); + } + + if (type == typeof(DG.Tweening.Core.DOGetter)) + { + return new DG.Tweening.Core.DOGetter(__Gen_Delegate_Imp121); + } + + if (type == typeof(DG.Tweening.Core.DOSetter)) + { + return new DG.Tweening.Core.DOSetter(__Gen_Delegate_Imp122); + } + + if (type == typeof(DG.Tweening.Core.DOGetter)) + { + return new DG.Tweening.Core.DOGetter(__Gen_Delegate_Imp123); + } + + if (type == typeof(DG.Tweening.Core.DOSetter)) + { + return new DG.Tweening.Core.DOSetter(__Gen_Delegate_Imp124); + } + + if (type == typeof(DG.Tweening.Core.DOGetter)) + { + return new DG.Tweening.Core.DOGetter(__Gen_Delegate_Imp125); + } + + if (type == typeof(DG.Tweening.Core.DOSetter)) + { + return new DG.Tweening.Core.DOSetter(__Gen_Delegate_Imp126); + } + + if (type == typeof(DG.Tweening.Core.DOGetter)) + { + return new DG.Tweening.Core.DOGetter(__Gen_Delegate_Imp127); + } + + if (type == typeof(DG.Tweening.Core.DOSetter)) + { + return new DG.Tweening.Core.DOSetter(__Gen_Delegate_Imp128); + } + + if (type == typeof(DG.Tweening.EaseFunction)) + { + return new DG.Tweening.EaseFunction(__Gen_Delegate_Imp129); + } + + if (type == typeof(System.Func)) + { + return new System.Func(__Gen_Delegate_Imp130); + } + + if (type == typeof(BestHTTP.OnBeforeRedirectionDelegate)) + { + return new BestHTTP.OnBeforeRedirectionDelegate(__Gen_Delegate_Imp131); + } + + if (type == typeof(BestHTTP.OnBeforeHeaderSendDelegate)) + { + return new BestHTTP.OnBeforeHeaderSendDelegate(__Gen_Delegate_Imp132); + } + + if (type == typeof(BestHTTP.OnHeaderEnumerationDelegate)) + { + return new BestHTTP.OnHeaderEnumerationDelegate(__Gen_Delegate_Imp133); + } + + if (type == typeof(System.Action>)) + { + return new System.Action>(__Gen_Delegate_Imp134); + } + + return null; + } + } + +} \ No newline at end of file diff --git a/Assets/XLua/Gen/EnumWrap.cs b/Assets/XLua/Gen/EnumWrap.cs new file mode 100644 index 000000000..6b43ad253 --- /dev/null +++ b/Assets/XLua/Gen/EnumWrap.cs @@ -0,0 +1,5673 @@ +#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 AdFormatWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(AdFormat), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(AdFormat), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(AdFormat), L, null, 4, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RewardedVideo", AdFormat.RewardedVideo); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Interstitial", AdFormat.Interstitial); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Banner", AdFormat.Banner); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(AdFormat), 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.PushAdFormat(L, (AdFormat)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "RewardedVideo")) + { + translator.PushAdFormat(L, AdFormat.RewardedVideo); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Interstitial")) + { + translator.PushAdFormat(L, AdFormat.Interstitial); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Banner")) + { + translator.PushAdFormat(L, AdFormat.Banner); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for AdFormat!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for AdFormat! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class IronSourceBannerPositionWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(IronSourceBannerPosition), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(IronSourceBannerPosition), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(IronSourceBannerPosition), L, null, 3, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TOP", IronSourceBannerPosition.TOP); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BOTTOM", IronSourceBannerPosition.BOTTOM); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(IronSourceBannerPosition), 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.PushIronSourceBannerPosition(L, (IronSourceBannerPosition)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "TOP")) + { + translator.PushIronSourceBannerPosition(L, IronSourceBannerPosition.TOP); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "BOTTOM")) + { + translator.PushIronSourceBannerPosition(L, IronSourceBannerPosition.BOTTOM); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for IronSourceBannerPosition!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for IronSourceBannerPosition! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UIImageSheetAnimationAnimationTypeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UIImageSheetAnimation.AnimationType), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UIImageSheetAnimation.AnimationType), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UIImageSheetAnimation.AnimationType), L, null, 3, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WholeSheet", UIImageSheetAnimation.AnimationType.WholeSheet); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SingleRow", UIImageSheetAnimation.AnimationType.SingleRow); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UIImageSheetAnimation.AnimationType), 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.PushUIImageSheetAnimationAnimationType(L, (UIImageSheetAnimation.AnimationType)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "WholeSheet")) + { + translator.PushUIImageSheetAnimationAnimationType(L, UIImageSheetAnimation.AnimationType.WholeSheet); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "SingleRow")) + { + translator.PushUIImageSheetAnimationAnimationType(L, UIImageSheetAnimation.AnimationType.SingleRow); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UIImageSheetAnimation.AnimationType!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UIImageSheetAnimation.AnimationType! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UIImageSheetAnimationTimeTypeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UIImageSheetAnimation.TimeType), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UIImageSheetAnimation.TimeType), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UIImageSheetAnimation.TimeType), L, null, 3, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LifeTime", UIImageSheetAnimation.TimeType.LifeTime); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FPS", UIImageSheetAnimation.TimeType.FPS); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UIImageSheetAnimation.TimeType), 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.PushUIImageSheetAnimationTimeType(L, (UIImageSheetAnimation.TimeType)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "LifeTime")) + { + translator.PushUIImageSheetAnimationTimeType(L, UIImageSheetAnimation.TimeType.LifeTime); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "FPS")) + { + translator.PushUIImageSheetAnimationTimeType(L, UIImageSheetAnimation.TimeType.FPS); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UIImageSheetAnimation.TimeType!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UIImageSheetAnimation.TimeType! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UIImageSheetAnimationStartFrameTypeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UIImageSheetAnimation.StartFrameType), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UIImageSheetAnimation.StartFrameType), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UIImageSheetAnimation.StartFrameType), L, null, 3, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Constant", UIImageSheetAnimation.StartFrameType.Constant); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RandomBetweenTwoConstants", UIImageSheetAnimation.StartFrameType.RandomBetweenTwoConstants); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UIImageSheetAnimation.StartFrameType), 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.PushUIImageSheetAnimationStartFrameType(L, (UIImageSheetAnimation.StartFrameType)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Constant")) + { + translator.PushUIImageSheetAnimationStartFrameType(L, UIImageSheetAnimation.StartFrameType.Constant); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "RandomBetweenTwoConstants")) + { + translator.PushUIImageSheetAnimationStartFrameType(L, UIImageSheetAnimation.StartFrameType.RandomBetweenTwoConstants); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UIImageSheetAnimation.StartFrameType!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UIImageSheetAnimation.StartFrameType! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class SystemReflectionBindingFlagsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(System.Reflection.BindingFlags), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(System.Reflection.BindingFlags), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(System.Reflection.BindingFlags), L, null, 22, 0, 0); + + Utils.RegisterEnumType(L, typeof(System.Reflection.BindingFlags)); + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(System.Reflection.BindingFlags), 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.PushSystemReflectionBindingFlags(L, (System.Reflection.BindingFlags)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + try + { + translator.TranslateToEnumToTop(L, typeof(System.Reflection.BindingFlags), 1); + } + catch (System.Exception e) + { + return LuaAPI.luaL_error(L, "cast to " + typeof(System.Reflection.BindingFlags) + " exception:" + e); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for System.Reflection.BindingFlags! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class SystemDayOfWeekWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(System.DayOfWeek), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(System.DayOfWeek), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(System.DayOfWeek), L, null, 8, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Sunday", System.DayOfWeek.Sunday); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Monday", System.DayOfWeek.Monday); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Tuesday", System.DayOfWeek.Tuesday); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Wednesday", System.DayOfWeek.Wednesday); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Thursday", System.DayOfWeek.Thursday); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Friday", System.DayOfWeek.Friday); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Saturday", System.DayOfWeek.Saturday); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(System.DayOfWeek), 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.PushSystemDayOfWeek(L, (System.DayOfWeek)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Sunday")) + { + translator.PushSystemDayOfWeek(L, System.DayOfWeek.Sunday); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Monday")) + { + translator.PushSystemDayOfWeek(L, System.DayOfWeek.Monday); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Tuesday")) + { + translator.PushSystemDayOfWeek(L, System.DayOfWeek.Tuesday); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Wednesday")) + { + translator.PushSystemDayOfWeek(L, System.DayOfWeek.Wednesday); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Thursday")) + { + translator.PushSystemDayOfWeek(L, System.DayOfWeek.Thursday); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Friday")) + { + translator.PushSystemDayOfWeek(L, System.DayOfWeek.Friday); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Saturday")) + { + translator.PushSystemDayOfWeek(L, System.DayOfWeek.Saturday); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for System.DayOfWeek!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for System.DayOfWeek! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class SystemNetNetworkInformationIPStatusWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(System.Net.NetworkInformation.IPStatus), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(System.Net.NetworkInformation.IPStatus), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(System.Net.NetworkInformation.IPStatus), L, null, 25, 0, 0); + + Utils.RegisterEnumType(L, typeof(System.Net.NetworkInformation.IPStatus)); + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(System.Net.NetworkInformation.IPStatus), 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.PushSystemNetNetworkInformationIPStatus(L, (System.Net.NetworkInformation.IPStatus)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + try + { + translator.TranslateToEnumToTop(L, typeof(System.Net.NetworkInformation.IPStatus), 1); + } + catch (System.Exception e) + { + return LuaAPI.luaL_error(L, "cast to " + typeof(System.Net.NetworkInformation.IPStatus) + " exception:" + e); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for System.Net.NetworkInformation.IPStatus! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineCameraGateFitModeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.Camera.GateFitMode), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.Camera.GateFitMode), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.Camera.GateFitMode), L, null, 6, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Vertical", UnityEngine.Camera.GateFitMode.Vertical); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Horizontal", UnityEngine.Camera.GateFitMode.Horizontal); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fill", UnityEngine.Camera.GateFitMode.Fill); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Overscan", UnityEngine.Camera.GateFitMode.Overscan); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.Camera.GateFitMode.None); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.Camera.GateFitMode), 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.PushUnityEngineCameraGateFitMode(L, (UnityEngine.Camera.GateFitMode)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Vertical")) + { + translator.PushUnityEngineCameraGateFitMode(L, UnityEngine.Camera.GateFitMode.Vertical); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Horizontal")) + { + translator.PushUnityEngineCameraGateFitMode(L, UnityEngine.Camera.GateFitMode.Horizontal); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Fill")) + { + translator.PushUnityEngineCameraGateFitMode(L, UnityEngine.Camera.GateFitMode.Fill); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Overscan")) + { + translator.PushUnityEngineCameraGateFitMode(L, UnityEngine.Camera.GateFitMode.Overscan); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "None")) + { + translator.PushUnityEngineCameraGateFitMode(L, UnityEngine.Camera.GateFitMode.None); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Camera.GateFitMode!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Camera.GateFitMode! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineCameraStereoscopicEyeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.Camera.StereoscopicEye), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.Camera.StereoscopicEye), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.Camera.StereoscopicEye), L, null, 3, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Left", UnityEngine.Camera.StereoscopicEye.Left); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Right", UnityEngine.Camera.StereoscopicEye.Right); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.Camera.StereoscopicEye), 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.PushUnityEngineCameraStereoscopicEye(L, (UnityEngine.Camera.StereoscopicEye)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Left")) + { + translator.PushUnityEngineCameraStereoscopicEye(L, UnityEngine.Camera.StereoscopicEye.Left); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Right")) + { + translator.PushUnityEngineCameraStereoscopicEye(L, UnityEngine.Camera.StereoscopicEye.Right); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Camera.StereoscopicEye!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Camera.StereoscopicEye! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineCameraMonoOrStereoscopicEyeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.Camera.MonoOrStereoscopicEye), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.Camera.MonoOrStereoscopicEye), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.Camera.MonoOrStereoscopicEye), L, null, 4, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Left", UnityEngine.Camera.MonoOrStereoscopicEye.Left); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Right", UnityEngine.Camera.MonoOrStereoscopicEye.Right); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mono", UnityEngine.Camera.MonoOrStereoscopicEye.Mono); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.Camera.MonoOrStereoscopicEye), 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.PushUnityEngineCameraMonoOrStereoscopicEye(L, (UnityEngine.Camera.MonoOrStereoscopicEye)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Left")) + { + translator.PushUnityEngineCameraMonoOrStereoscopicEye(L, UnityEngine.Camera.MonoOrStereoscopicEye.Left); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Right")) + { + translator.PushUnityEngineCameraMonoOrStereoscopicEye(L, UnityEngine.Camera.MonoOrStereoscopicEye.Right); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Mono")) + { + translator.PushUnityEngineCameraMonoOrStereoscopicEye(L, UnityEngine.Camera.MonoOrStereoscopicEye.Mono); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Camera.MonoOrStereoscopicEye!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Camera.MonoOrStereoscopicEye! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineCameraFieldOfViewAxisWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.Camera.FieldOfViewAxis), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.Camera.FieldOfViewAxis), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.Camera.FieldOfViewAxis), L, null, 3, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Vertical", UnityEngine.Camera.FieldOfViewAxis.Vertical); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Horizontal", UnityEngine.Camera.FieldOfViewAxis.Horizontal); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.Camera.FieldOfViewAxis), 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.PushUnityEngineCameraFieldOfViewAxis(L, (UnityEngine.Camera.FieldOfViewAxis)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Vertical")) + { + translator.PushUnityEngineCameraFieldOfViewAxis(L, UnityEngine.Camera.FieldOfViewAxis.Vertical); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Horizontal")) + { + translator.PushUnityEngineCameraFieldOfViewAxis(L, UnityEngine.Camera.FieldOfViewAxis.Horizontal); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Camera.FieldOfViewAxis!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Camera.FieldOfViewAxis! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineCameraRenderRequestModeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.Camera.RenderRequestMode), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.Camera.RenderRequestMode), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.Camera.RenderRequestMode), L, null, 15, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.Camera.RenderRequestMode.None); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ObjectId", UnityEngine.Camera.RenderRequestMode.ObjectId); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Depth", UnityEngine.Camera.RenderRequestMode.Depth); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VertexNormal", UnityEngine.Camera.RenderRequestMode.VertexNormal); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WorldPosition", UnityEngine.Camera.RenderRequestMode.WorldPosition); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EntityId", UnityEngine.Camera.RenderRequestMode.EntityId); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BaseColor", UnityEngine.Camera.RenderRequestMode.BaseColor); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SpecularColor", UnityEngine.Camera.RenderRequestMode.SpecularColor); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Metallic", UnityEngine.Camera.RenderRequestMode.Metallic); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Emission", UnityEngine.Camera.RenderRequestMode.Emission); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", UnityEngine.Camera.RenderRequestMode.Normal); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Smoothness", UnityEngine.Camera.RenderRequestMode.Smoothness); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Occlusion", UnityEngine.Camera.RenderRequestMode.Occlusion); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DiffuseColor", UnityEngine.Camera.RenderRequestMode.DiffuseColor); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.Camera.RenderRequestMode), 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.PushUnityEngineCameraRenderRequestMode(L, (UnityEngine.Camera.RenderRequestMode)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "None")) + { + translator.PushUnityEngineCameraRenderRequestMode(L, UnityEngine.Camera.RenderRequestMode.None); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "ObjectId")) + { + translator.PushUnityEngineCameraRenderRequestMode(L, UnityEngine.Camera.RenderRequestMode.ObjectId); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Depth")) + { + translator.PushUnityEngineCameraRenderRequestMode(L, UnityEngine.Camera.RenderRequestMode.Depth); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "VertexNormal")) + { + translator.PushUnityEngineCameraRenderRequestMode(L, UnityEngine.Camera.RenderRequestMode.VertexNormal); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "WorldPosition")) + { + translator.PushUnityEngineCameraRenderRequestMode(L, UnityEngine.Camera.RenderRequestMode.WorldPosition); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "EntityId")) + { + translator.PushUnityEngineCameraRenderRequestMode(L, UnityEngine.Camera.RenderRequestMode.EntityId); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "BaseColor")) + { + translator.PushUnityEngineCameraRenderRequestMode(L, UnityEngine.Camera.RenderRequestMode.BaseColor); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "SpecularColor")) + { + translator.PushUnityEngineCameraRenderRequestMode(L, UnityEngine.Camera.RenderRequestMode.SpecularColor); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Metallic")) + { + translator.PushUnityEngineCameraRenderRequestMode(L, UnityEngine.Camera.RenderRequestMode.Metallic); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Emission")) + { + translator.PushUnityEngineCameraRenderRequestMode(L, UnityEngine.Camera.RenderRequestMode.Emission); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Normal")) + { + translator.PushUnityEngineCameraRenderRequestMode(L, UnityEngine.Camera.RenderRequestMode.Normal); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Smoothness")) + { + translator.PushUnityEngineCameraRenderRequestMode(L, UnityEngine.Camera.RenderRequestMode.Smoothness); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Occlusion")) + { + translator.PushUnityEngineCameraRenderRequestMode(L, UnityEngine.Camera.RenderRequestMode.Occlusion); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "DiffuseColor")) + { + translator.PushUnityEngineCameraRenderRequestMode(L, UnityEngine.Camera.RenderRequestMode.DiffuseColor); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Camera.RenderRequestMode!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Camera.RenderRequestMode! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineCameraRenderRequestOutputSpaceWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.Camera.RenderRequestOutputSpace), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.Camera.RenderRequestOutputSpace), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.Camera.RenderRequestOutputSpace), L, null, 11, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ScreenSpace", UnityEngine.Camera.RenderRequestOutputSpace.ScreenSpace); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UV0", UnityEngine.Camera.RenderRequestOutputSpace.UV0); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UV1", UnityEngine.Camera.RenderRequestOutputSpace.UV1); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UV2", UnityEngine.Camera.RenderRequestOutputSpace.UV2); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UV3", UnityEngine.Camera.RenderRequestOutputSpace.UV3); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UV4", UnityEngine.Camera.RenderRequestOutputSpace.UV4); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UV5", UnityEngine.Camera.RenderRequestOutputSpace.UV5); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UV6", UnityEngine.Camera.RenderRequestOutputSpace.UV6); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UV7", UnityEngine.Camera.RenderRequestOutputSpace.UV7); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UV8", UnityEngine.Camera.RenderRequestOutputSpace.UV8); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.Camera.RenderRequestOutputSpace), 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.PushUnityEngineCameraRenderRequestOutputSpace(L, (UnityEngine.Camera.RenderRequestOutputSpace)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "ScreenSpace")) + { + translator.PushUnityEngineCameraRenderRequestOutputSpace(L, UnityEngine.Camera.RenderRequestOutputSpace.ScreenSpace); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "UV0")) + { + translator.PushUnityEngineCameraRenderRequestOutputSpace(L, UnityEngine.Camera.RenderRequestOutputSpace.UV0); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "UV1")) + { + translator.PushUnityEngineCameraRenderRequestOutputSpace(L, UnityEngine.Camera.RenderRequestOutputSpace.UV1); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "UV2")) + { + translator.PushUnityEngineCameraRenderRequestOutputSpace(L, UnityEngine.Camera.RenderRequestOutputSpace.UV2); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "UV3")) + { + translator.PushUnityEngineCameraRenderRequestOutputSpace(L, UnityEngine.Camera.RenderRequestOutputSpace.UV3); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "UV4")) + { + translator.PushUnityEngineCameraRenderRequestOutputSpace(L, UnityEngine.Camera.RenderRequestOutputSpace.UV4); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "UV5")) + { + translator.PushUnityEngineCameraRenderRequestOutputSpace(L, UnityEngine.Camera.RenderRequestOutputSpace.UV5); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "UV6")) + { + translator.PushUnityEngineCameraRenderRequestOutputSpace(L, UnityEngine.Camera.RenderRequestOutputSpace.UV6); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "UV7")) + { + translator.PushUnityEngineCameraRenderRequestOutputSpace(L, UnityEngine.Camera.RenderRequestOutputSpace.UV7); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "UV8")) + { + translator.PushUnityEngineCameraRenderRequestOutputSpace(L, UnityEngine.Camera.RenderRequestOutputSpace.UV8); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Camera.RenderRequestOutputSpace!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Camera.RenderRequestOutputSpace! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineCameraSceneViewFilterModeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.Camera.SceneViewFilterMode), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.Camera.SceneViewFilterMode), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.Camera.SceneViewFilterMode), L, null, 3, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Off", UnityEngine.Camera.SceneViewFilterMode.Off); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ShowFiltered", UnityEngine.Camera.SceneViewFilterMode.ShowFiltered); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.Camera.SceneViewFilterMode), 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.PushUnityEngineCameraSceneViewFilterMode(L, (UnityEngine.Camera.SceneViewFilterMode)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Off")) + { + translator.PushUnityEngineCameraSceneViewFilterMode(L, UnityEngine.Camera.SceneViewFilterMode.Off); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "ShowFiltered")) + { + translator.PushUnityEngineCameraSceneViewFilterMode(L, UnityEngine.Camera.SceneViewFilterMode.ShowFiltered); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Camera.SceneViewFilterMode!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Camera.SceneViewFilterMode! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineRenderingLightShadowResolutionWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.LightShadowResolution), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.Rendering.LightShadowResolution), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.Rendering.LightShadowResolution), L, null, 6, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FromQualitySettings", UnityEngine.Rendering.LightShadowResolution.FromQualitySettings); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Low", UnityEngine.Rendering.LightShadowResolution.Low); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Medium", UnityEngine.Rendering.LightShadowResolution.Medium); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "High", UnityEngine.Rendering.LightShadowResolution.High); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VeryHigh", UnityEngine.Rendering.LightShadowResolution.VeryHigh); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.Rendering.LightShadowResolution), 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.PushUnityEngineRenderingLightShadowResolution(L, (UnityEngine.Rendering.LightShadowResolution)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "FromQualitySettings")) + { + translator.PushUnityEngineRenderingLightShadowResolution(L, UnityEngine.Rendering.LightShadowResolution.FromQualitySettings); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Low")) + { + translator.PushUnityEngineRenderingLightShadowResolution(L, UnityEngine.Rendering.LightShadowResolution.Low); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Medium")) + { + translator.PushUnityEngineRenderingLightShadowResolution(L, UnityEngine.Rendering.LightShadowResolution.Medium); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "High")) + { + translator.PushUnityEngineRenderingLightShadowResolution(L, UnityEngine.Rendering.LightShadowResolution.High); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "VeryHigh")) + { + translator.PushUnityEngineRenderingLightShadowResolution(L, UnityEngine.Rendering.LightShadowResolution.VeryHigh); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.LightShadowResolution!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.LightShadowResolution! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineRenderTextureFormatWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.RenderTextureFormat), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.RenderTextureFormat), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.RenderTextureFormat), L, null, 29, 0, 0); + + Utils.RegisterEnumType(L, typeof(UnityEngine.RenderTextureFormat)); + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.RenderTextureFormat), 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.PushUnityEngineRenderTextureFormat(L, (UnityEngine.RenderTextureFormat)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + try + { + translator.TranslateToEnumToTop(L, typeof(UnityEngine.RenderTextureFormat), 1); + } + catch (System.Exception e) + { + return LuaAPI.luaL_error(L, "cast to " + typeof(UnityEngine.RenderTextureFormat) + " exception:" + e); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.RenderTextureFormat! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineRenderTextureReadWriteWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.RenderTextureReadWrite), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.RenderTextureReadWrite), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.RenderTextureReadWrite), L, null, 4, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Default", UnityEngine.RenderTextureReadWrite.Default); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Linear", UnityEngine.RenderTextureReadWrite.Linear); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "sRGB", UnityEngine.RenderTextureReadWrite.sRGB); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.RenderTextureReadWrite), 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.PushUnityEngineRenderTextureReadWrite(L, (UnityEngine.RenderTextureReadWrite)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Default")) + { + translator.PushUnityEngineRenderTextureReadWrite(L, UnityEngine.RenderTextureReadWrite.Default); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Linear")) + { + translator.PushUnityEngineRenderTextureReadWrite(L, UnityEngine.RenderTextureReadWrite.Linear); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "sRGB")) + { + translator.PushUnityEngineRenderTextureReadWrite(L, UnityEngine.RenderTextureReadWrite.sRGB); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.RenderTextureReadWrite!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.RenderTextureReadWrite! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineRigidbodyConstraintsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.RigidbodyConstraints), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.RigidbodyConstraints), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.RigidbodyConstraints), L, null, 11, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.RigidbodyConstraints.None); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreezePositionX", UnityEngine.RigidbodyConstraints.FreezePositionX); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreezePositionY", UnityEngine.RigidbodyConstraints.FreezePositionY); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreezePositionZ", UnityEngine.RigidbodyConstraints.FreezePositionZ); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreezeRotationX", UnityEngine.RigidbodyConstraints.FreezeRotationX); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreezeRotationY", UnityEngine.RigidbodyConstraints.FreezeRotationY); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreezeRotationZ", UnityEngine.RigidbodyConstraints.FreezeRotationZ); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreezePosition", UnityEngine.RigidbodyConstraints.FreezePosition); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreezeRotation", UnityEngine.RigidbodyConstraints.FreezeRotation); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreezeAll", UnityEngine.RigidbodyConstraints.FreezeAll); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.RigidbodyConstraints), 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.PushUnityEngineRigidbodyConstraints(L, (UnityEngine.RigidbodyConstraints)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "None")) + { + translator.PushUnityEngineRigidbodyConstraints(L, UnityEngine.RigidbodyConstraints.None); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "FreezePositionX")) + { + translator.PushUnityEngineRigidbodyConstraints(L, UnityEngine.RigidbodyConstraints.FreezePositionX); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "FreezePositionY")) + { + translator.PushUnityEngineRigidbodyConstraints(L, UnityEngine.RigidbodyConstraints.FreezePositionY); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "FreezePositionZ")) + { + translator.PushUnityEngineRigidbodyConstraints(L, UnityEngine.RigidbodyConstraints.FreezePositionZ); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "FreezeRotationX")) + { + translator.PushUnityEngineRigidbodyConstraints(L, UnityEngine.RigidbodyConstraints.FreezeRotationX); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "FreezeRotationY")) + { + translator.PushUnityEngineRigidbodyConstraints(L, UnityEngine.RigidbodyConstraints.FreezeRotationY); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "FreezeRotationZ")) + { + translator.PushUnityEngineRigidbodyConstraints(L, UnityEngine.RigidbodyConstraints.FreezeRotationZ); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "FreezePosition")) + { + translator.PushUnityEngineRigidbodyConstraints(L, UnityEngine.RigidbodyConstraints.FreezePosition); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "FreezeRotation")) + { + translator.PushUnityEngineRigidbodyConstraints(L, UnityEngine.RigidbodyConstraints.FreezeRotation); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "FreezeAll")) + { + translator.PushUnityEngineRigidbodyConstraints(L, UnityEngine.RigidbodyConstraints.FreezeAll); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.RigidbodyConstraints!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.RigidbodyConstraints! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineTransparencySortModeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.TransparencySortMode), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.TransparencySortMode), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.TransparencySortMode), L, null, 5, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Default", UnityEngine.TransparencySortMode.Default); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Perspective", UnityEngine.TransparencySortMode.Perspective); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Orthographic", UnityEngine.TransparencySortMode.Orthographic); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CustomAxis", UnityEngine.TransparencySortMode.CustomAxis); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.TransparencySortMode), 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.PushUnityEngineTransparencySortMode(L, (UnityEngine.TransparencySortMode)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Default")) + { + translator.PushUnityEngineTransparencySortMode(L, UnityEngine.TransparencySortMode.Default); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Perspective")) + { + translator.PushUnityEngineTransparencySortMode(L, UnityEngine.TransparencySortMode.Perspective); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Orthographic")) + { + translator.PushUnityEngineTransparencySortMode(L, UnityEngine.TransparencySortMode.Orthographic); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "CustomAxis")) + { + translator.PushUnityEngineTransparencySortMode(L, UnityEngine.TransparencySortMode.CustomAxis); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.TransparencySortMode!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.TransparencySortMode! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineRectTransformAxisWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.RectTransform.Axis), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.RectTransform.Axis), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.RectTransform.Axis), L, null, 3, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Horizontal", UnityEngine.RectTransform.Axis.Horizontal); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Vertical", UnityEngine.RectTransform.Axis.Vertical); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.RectTransform.Axis), 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.PushUnityEngineRectTransformAxis(L, (UnityEngine.RectTransform.Axis)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Horizontal")) + { + translator.PushUnityEngineRectTransformAxis(L, UnityEngine.RectTransform.Axis.Horizontal); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Vertical")) + { + translator.PushUnityEngineRectTransformAxis(L, UnityEngine.RectTransform.Axis.Vertical); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.RectTransform.Axis!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.RectTransform.Axis! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineRectTransformEdgeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.RectTransform.Edge), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.RectTransform.Edge), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.RectTransform.Edge), L, null, 5, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Left", UnityEngine.RectTransform.Edge.Left); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Right", UnityEngine.RectTransform.Edge.Right); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Top", UnityEngine.RectTransform.Edge.Top); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Bottom", UnityEngine.RectTransform.Edge.Bottom); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.RectTransform.Edge), 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.PushUnityEngineRectTransformEdge(L, (UnityEngine.RectTransform.Edge)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Left")) + { + translator.PushUnityEngineRectTransformEdge(L, UnityEngine.RectTransform.Edge.Left); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Right")) + { + translator.PushUnityEngineRectTransformEdge(L, UnityEngine.RectTransform.Edge.Right); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Top")) + { + translator.PushUnityEngineRectTransformEdge(L, UnityEngine.RectTransform.Edge.Top); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Bottom")) + { + translator.PushUnityEngineRectTransformEdge(L, UnityEngine.RectTransform.Edge.Bottom); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.RectTransform.Edge!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.RectTransform.Edge! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineAnimatorCullingModeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.AnimatorCullingMode), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.AnimatorCullingMode), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.AnimatorCullingMode), L, null, 5, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AlwaysAnimate", UnityEngine.AnimatorCullingMode.AlwaysAnimate); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CullUpdateTransforms", UnityEngine.AnimatorCullingMode.CullUpdateTransforms); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CullCompletely", UnityEngine.AnimatorCullingMode.CullCompletely); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.AnimatorCullingMode), 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.PushUnityEngineAnimatorCullingMode(L, (UnityEngine.AnimatorCullingMode)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "AlwaysAnimate")) + { + translator.PushUnityEngineAnimatorCullingMode(L, UnityEngine.AnimatorCullingMode.AlwaysAnimate); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "CullUpdateTransforms")) + { + translator.PushUnityEngineAnimatorCullingMode(L, UnityEngine.AnimatorCullingMode.CullUpdateTransforms); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "CullCompletely")) + { + translator.PushUnityEngineAnimatorCullingMode(L, UnityEngine.AnimatorCullingMode.CullCompletely); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.AnimatorCullingMode!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.AnimatorCullingMode! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineSystemLanguageWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.SystemLanguage), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.SystemLanguage), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.SystemLanguage), L, null, 45, 0, 0); + + Utils.RegisterEnumType(L, typeof(UnityEngine.SystemLanguage)); + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.SystemLanguage), 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.PushUnityEngineSystemLanguage(L, (UnityEngine.SystemLanguage)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + try + { + translator.TranslateToEnumToTop(L, typeof(UnityEngine.SystemLanguage), 1); + } + catch (System.Exception e) + { + return LuaAPI.luaL_error(L, "cast to " + typeof(UnityEngine.SystemLanguage) + " exception:" + e); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.SystemLanguage! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineRenderingShadowCastingModeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.ShadowCastingMode), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.Rendering.ShadowCastingMode), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.Rendering.ShadowCastingMode), L, null, 5, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Off", UnityEngine.Rendering.ShadowCastingMode.Off); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "On", UnityEngine.Rendering.ShadowCastingMode.On); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TwoSided", UnityEngine.Rendering.ShadowCastingMode.TwoSided); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ShadowsOnly", UnityEngine.Rendering.ShadowCastingMode.ShadowsOnly); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.Rendering.ShadowCastingMode), 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.PushUnityEngineRenderingShadowCastingMode(L, (UnityEngine.Rendering.ShadowCastingMode)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Off")) + { + translator.PushUnityEngineRenderingShadowCastingMode(L, UnityEngine.Rendering.ShadowCastingMode.Off); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "On")) + { + translator.PushUnityEngineRenderingShadowCastingMode(L, UnityEngine.Rendering.ShadowCastingMode.On); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "TwoSided")) + { + translator.PushUnityEngineRenderingShadowCastingMode(L, UnityEngine.Rendering.ShadowCastingMode.TwoSided); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "ShadowsOnly")) + { + translator.PushUnityEngineRenderingShadowCastingMode(L, UnityEngine.Rendering.ShadowCastingMode.ShadowsOnly); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.ShadowCastingMode!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.ShadowCastingMode! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineTexture2DEXRFlagsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.Texture2D.EXRFlags), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.Texture2D.EXRFlags), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.Texture2D.EXRFlags), L, null, 6, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.Texture2D.EXRFlags.None); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OutputAsFloat", UnityEngine.Texture2D.EXRFlags.OutputAsFloat); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CompressZIP", UnityEngine.Texture2D.EXRFlags.CompressZIP); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CompressRLE", UnityEngine.Texture2D.EXRFlags.CompressRLE); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CompressPIZ", UnityEngine.Texture2D.EXRFlags.CompressPIZ); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.Texture2D.EXRFlags), 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.PushUnityEngineTexture2DEXRFlags(L, (UnityEngine.Texture2D.EXRFlags)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "None")) + { + translator.PushUnityEngineTexture2DEXRFlags(L, UnityEngine.Texture2D.EXRFlags.None); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "OutputAsFloat")) + { + translator.PushUnityEngineTexture2DEXRFlags(L, UnityEngine.Texture2D.EXRFlags.OutputAsFloat); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "CompressZIP")) + { + translator.PushUnityEngineTexture2DEXRFlags(L, UnityEngine.Texture2D.EXRFlags.CompressZIP); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "CompressRLE")) + { + translator.PushUnityEngineTexture2DEXRFlags(L, UnityEngine.Texture2D.EXRFlags.CompressRLE); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "CompressPIZ")) + { + translator.PushUnityEngineTexture2DEXRFlags(L, UnityEngine.Texture2D.EXRFlags.CompressPIZ); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Texture2D.EXRFlags!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Texture2D.EXRFlags! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineKeyCodeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.KeyCode), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.KeyCode), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.KeyCode), L, null, 329, 0, 0); + + Utils.RegisterEnumType(L, typeof(UnityEngine.KeyCode)); + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.KeyCode), 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.PushUnityEngineKeyCode(L, (UnityEngine.KeyCode)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + try + { + translator.TranslateToEnumToTop(L, typeof(UnityEngine.KeyCode), 1); + } + catch (System.Exception e) + { + return LuaAPI.luaL_error(L, "cast to " + typeof(UnityEngine.KeyCode) + " exception:" + e); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.KeyCode! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineNetworkReachabilityWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.NetworkReachability), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.NetworkReachability), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.NetworkReachability), L, null, 4, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NotReachable", UnityEngine.NetworkReachability.NotReachable); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReachableViaCarrierDataNetwork", UnityEngine.NetworkReachability.ReachableViaCarrierDataNetwork); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReachableViaLocalAreaNetwork", UnityEngine.NetworkReachability.ReachableViaLocalAreaNetwork); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.NetworkReachability), 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.PushUnityEngineNetworkReachability(L, (UnityEngine.NetworkReachability)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "NotReachable")) + { + translator.PushUnityEngineNetworkReachability(L, UnityEngine.NetworkReachability.NotReachable); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "ReachableViaCarrierDataNetwork")) + { + translator.PushUnityEngineNetworkReachability(L, UnityEngine.NetworkReachability.ReachableViaCarrierDataNetwork); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "ReachableViaLocalAreaNetwork")) + { + translator.PushUnityEngineNetworkReachability(L, UnityEngine.NetworkReachability.ReachableViaLocalAreaNetwork); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.NetworkReachability!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.NetworkReachability! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineRuntimePlatformWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.RuntimePlatform), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.RuntimePlatform), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.RuntimePlatform), L, null, 49, 0, 0); + + Utils.RegisterEnumType(L, typeof(UnityEngine.RuntimePlatform)); + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.RuntimePlatform), 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.PushUnityEngineRuntimePlatform(L, (UnityEngine.RuntimePlatform)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + try + { + translator.TranslateToEnumToTop(L, typeof(UnityEngine.RuntimePlatform), 1); + } + catch (System.Exception e) + { + return LuaAPI.luaL_error(L, "cast to " + typeof(UnityEngine.RuntimePlatform) + " exception:" + e); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.RuntimePlatform! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineRenderingCompareFunctionWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.Rendering.CompareFunction), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.Rendering.CompareFunction), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.Rendering.CompareFunction), L, null, 10, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Disabled", UnityEngine.Rendering.CompareFunction.Disabled); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Never", UnityEngine.Rendering.CompareFunction.Never); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Less", UnityEngine.Rendering.CompareFunction.Less); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equal", UnityEngine.Rendering.CompareFunction.Equal); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LessEqual", UnityEngine.Rendering.CompareFunction.LessEqual); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Greater", UnityEngine.Rendering.CompareFunction.Greater); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NotEqual", UnityEngine.Rendering.CompareFunction.NotEqual); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GreaterEqual", UnityEngine.Rendering.CompareFunction.GreaterEqual); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Always", UnityEngine.Rendering.CompareFunction.Always); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.Rendering.CompareFunction), 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.PushUnityEngineRenderingCompareFunction(L, (UnityEngine.Rendering.CompareFunction)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Disabled")) + { + translator.PushUnityEngineRenderingCompareFunction(L, UnityEngine.Rendering.CompareFunction.Disabled); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Never")) + { + translator.PushUnityEngineRenderingCompareFunction(L, UnityEngine.Rendering.CompareFunction.Never); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Less")) + { + translator.PushUnityEngineRenderingCompareFunction(L, UnityEngine.Rendering.CompareFunction.Less); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Equal")) + { + translator.PushUnityEngineRenderingCompareFunction(L, UnityEngine.Rendering.CompareFunction.Equal); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "LessEqual")) + { + translator.PushUnityEngineRenderingCompareFunction(L, UnityEngine.Rendering.CompareFunction.LessEqual); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Greater")) + { + translator.PushUnityEngineRenderingCompareFunction(L, UnityEngine.Rendering.CompareFunction.Greater); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "NotEqual")) + { + translator.PushUnityEngineRenderingCompareFunction(L, UnityEngine.Rendering.CompareFunction.NotEqual); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "GreaterEqual")) + { + translator.PushUnityEngineRenderingCompareFunction(L, UnityEngine.Rendering.CompareFunction.GreaterEqual); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Always")) + { + translator.PushUnityEngineRenderingCompareFunction(L, UnityEngine.Rendering.CompareFunction.Always); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Rendering.CompareFunction!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Rendering.CompareFunction! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineTextAnchorWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.TextAnchor), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.TextAnchor), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.TextAnchor), L, null, 10, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UpperLeft", UnityEngine.TextAnchor.UpperLeft); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UpperCenter", UnityEngine.TextAnchor.UpperCenter); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UpperRight", UnityEngine.TextAnchor.UpperRight); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MiddleLeft", UnityEngine.TextAnchor.MiddleLeft); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MiddleCenter", UnityEngine.TextAnchor.MiddleCenter); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MiddleRight", UnityEngine.TextAnchor.MiddleRight); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LowerLeft", UnityEngine.TextAnchor.LowerLeft); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LowerCenter", UnityEngine.TextAnchor.LowerCenter); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LowerRight", UnityEngine.TextAnchor.LowerRight); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.TextAnchor), 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.PushUnityEngineTextAnchor(L, (UnityEngine.TextAnchor)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "UpperLeft")) + { + translator.PushUnityEngineTextAnchor(L, UnityEngine.TextAnchor.UpperLeft); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "UpperCenter")) + { + translator.PushUnityEngineTextAnchor(L, UnityEngine.TextAnchor.UpperCenter); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "UpperRight")) + { + translator.PushUnityEngineTextAnchor(L, UnityEngine.TextAnchor.UpperRight); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "MiddleLeft")) + { + translator.PushUnityEngineTextAnchor(L, UnityEngine.TextAnchor.MiddleLeft); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "MiddleCenter")) + { + translator.PushUnityEngineTextAnchor(L, UnityEngine.TextAnchor.MiddleCenter); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "MiddleRight")) + { + translator.PushUnityEngineTextAnchor(L, UnityEngine.TextAnchor.MiddleRight); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "LowerLeft")) + { + translator.PushUnityEngineTextAnchor(L, UnityEngine.TextAnchor.LowerLeft); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "LowerCenter")) + { + translator.PushUnityEngineTextAnchor(L, UnityEngine.TextAnchor.LowerCenter); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "LowerRight")) + { + translator.PushUnityEngineTextAnchor(L, UnityEngine.TextAnchor.LowerRight); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.TextAnchor!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.TextAnchor! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineBatteryStatusWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.BatteryStatus), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.BatteryStatus), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.BatteryStatus), L, null, 6, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Unknown", UnityEngine.BatteryStatus.Unknown); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Charging", UnityEngine.BatteryStatus.Charging); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Discharging", UnityEngine.BatteryStatus.Discharging); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NotCharging", UnityEngine.BatteryStatus.NotCharging); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Full", UnityEngine.BatteryStatus.Full); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.BatteryStatus), 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.PushUnityEngineBatteryStatus(L, (UnityEngine.BatteryStatus)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Unknown")) + { + translator.PushUnityEngineBatteryStatus(L, UnityEngine.BatteryStatus.Unknown); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Charging")) + { + translator.PushUnityEngineBatteryStatus(L, UnityEngine.BatteryStatus.Charging); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Discharging")) + { + translator.PushUnityEngineBatteryStatus(L, UnityEngine.BatteryStatus.Discharging); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "NotCharging")) + { + translator.PushUnityEngineBatteryStatus(L, UnityEngine.BatteryStatus.NotCharging); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Full")) + { + translator.PushUnityEngineBatteryStatus(L, UnityEngine.BatteryStatus.Full); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.BatteryStatus!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.BatteryStatus! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineUIGraphicRaycasterBlockingObjectsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.UI.GraphicRaycaster.BlockingObjects), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.UI.GraphicRaycaster.BlockingObjects), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.UI.GraphicRaycaster.BlockingObjects), L, null, 5, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.UI.GraphicRaycaster.BlockingObjects.None); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TwoD", UnityEngine.UI.GraphicRaycaster.BlockingObjects.TwoD); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ThreeD", UnityEngine.UI.GraphicRaycaster.BlockingObjects.ThreeD); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "All", UnityEngine.UI.GraphicRaycaster.BlockingObjects.All); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.UI.GraphicRaycaster.BlockingObjects), 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.PushUnityEngineUIGraphicRaycasterBlockingObjects(L, (UnityEngine.UI.GraphicRaycaster.BlockingObjects)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "None")) + { + translator.PushUnityEngineUIGraphicRaycasterBlockingObjects(L, UnityEngine.UI.GraphicRaycaster.BlockingObjects.None); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "TwoD")) + { + translator.PushUnityEngineUIGraphicRaycasterBlockingObjects(L, UnityEngine.UI.GraphicRaycaster.BlockingObjects.TwoD); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "ThreeD")) + { + translator.PushUnityEngineUIGraphicRaycasterBlockingObjects(L, UnityEngine.UI.GraphicRaycaster.BlockingObjects.ThreeD); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "All")) + { + translator.PushUnityEngineUIGraphicRaycasterBlockingObjects(L, UnityEngine.UI.GraphicRaycaster.BlockingObjects.All); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.GraphicRaycaster.BlockingObjects!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.GraphicRaycaster.BlockingObjects! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineUIImageTypeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.UI.Image.Type), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.UI.Image.Type), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.UI.Image.Type), L, null, 5, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Simple", UnityEngine.UI.Image.Type.Simple); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Sliced", UnityEngine.UI.Image.Type.Sliced); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Tiled", UnityEngine.UI.Image.Type.Tiled); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Filled", UnityEngine.UI.Image.Type.Filled); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.UI.Image.Type), 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.PushUnityEngineUIImageType(L, (UnityEngine.UI.Image.Type)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Simple")) + { + translator.PushUnityEngineUIImageType(L, UnityEngine.UI.Image.Type.Simple); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Sliced")) + { + translator.PushUnityEngineUIImageType(L, UnityEngine.UI.Image.Type.Sliced); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Tiled")) + { + translator.PushUnityEngineUIImageType(L, UnityEngine.UI.Image.Type.Tiled); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Filled")) + { + translator.PushUnityEngineUIImageType(L, UnityEngine.UI.Image.Type.Filled); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.Image.Type!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.Image.Type! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineUIImageFillMethodWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.UI.Image.FillMethod), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.UI.Image.FillMethod), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.UI.Image.FillMethod), L, null, 6, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Horizontal", UnityEngine.UI.Image.FillMethod.Horizontal); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Vertical", UnityEngine.UI.Image.FillMethod.Vertical); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Radial90", UnityEngine.UI.Image.FillMethod.Radial90); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Radial180", UnityEngine.UI.Image.FillMethod.Radial180); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Radial360", UnityEngine.UI.Image.FillMethod.Radial360); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.UI.Image.FillMethod), 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.PushUnityEngineUIImageFillMethod(L, (UnityEngine.UI.Image.FillMethod)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Horizontal")) + { + translator.PushUnityEngineUIImageFillMethod(L, UnityEngine.UI.Image.FillMethod.Horizontal); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Vertical")) + { + translator.PushUnityEngineUIImageFillMethod(L, UnityEngine.UI.Image.FillMethod.Vertical); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Radial90")) + { + translator.PushUnityEngineUIImageFillMethod(L, UnityEngine.UI.Image.FillMethod.Radial90); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Radial180")) + { + translator.PushUnityEngineUIImageFillMethod(L, UnityEngine.UI.Image.FillMethod.Radial180); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Radial360")) + { + translator.PushUnityEngineUIImageFillMethod(L, UnityEngine.UI.Image.FillMethod.Radial360); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.Image.FillMethod!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.Image.FillMethod! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineUIImageOriginHorizontalWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.UI.Image.OriginHorizontal), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.UI.Image.OriginHorizontal), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.UI.Image.OriginHorizontal), L, null, 3, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Left", UnityEngine.UI.Image.OriginHorizontal.Left); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Right", UnityEngine.UI.Image.OriginHorizontal.Right); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.UI.Image.OriginHorizontal), 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.PushUnityEngineUIImageOriginHorizontal(L, (UnityEngine.UI.Image.OriginHorizontal)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Left")) + { + translator.PushUnityEngineUIImageOriginHorizontal(L, UnityEngine.UI.Image.OriginHorizontal.Left); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Right")) + { + translator.PushUnityEngineUIImageOriginHorizontal(L, UnityEngine.UI.Image.OriginHorizontal.Right); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.Image.OriginHorizontal!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.Image.OriginHorizontal! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineUIImageOriginVerticalWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.UI.Image.OriginVertical), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.UI.Image.OriginVertical), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.UI.Image.OriginVertical), L, null, 3, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Bottom", UnityEngine.UI.Image.OriginVertical.Bottom); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Top", UnityEngine.UI.Image.OriginVertical.Top); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.UI.Image.OriginVertical), 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.PushUnityEngineUIImageOriginVertical(L, (UnityEngine.UI.Image.OriginVertical)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Bottom")) + { + translator.PushUnityEngineUIImageOriginVertical(L, UnityEngine.UI.Image.OriginVertical.Bottom); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Top")) + { + translator.PushUnityEngineUIImageOriginVertical(L, UnityEngine.UI.Image.OriginVertical.Top); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.Image.OriginVertical!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.Image.OriginVertical! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineUIImageOrigin90Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.UI.Image.Origin90), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.UI.Image.Origin90), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.UI.Image.Origin90), L, null, 5, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BottomLeft", UnityEngine.UI.Image.Origin90.BottomLeft); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TopLeft", UnityEngine.UI.Image.Origin90.TopLeft); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TopRight", UnityEngine.UI.Image.Origin90.TopRight); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BottomRight", UnityEngine.UI.Image.Origin90.BottomRight); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.UI.Image.Origin90), 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.PushUnityEngineUIImageOrigin90(L, (UnityEngine.UI.Image.Origin90)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "BottomLeft")) + { + translator.PushUnityEngineUIImageOrigin90(L, UnityEngine.UI.Image.Origin90.BottomLeft); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "TopLeft")) + { + translator.PushUnityEngineUIImageOrigin90(L, UnityEngine.UI.Image.Origin90.TopLeft); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "TopRight")) + { + translator.PushUnityEngineUIImageOrigin90(L, UnityEngine.UI.Image.Origin90.TopRight); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "BottomRight")) + { + translator.PushUnityEngineUIImageOrigin90(L, UnityEngine.UI.Image.Origin90.BottomRight); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.Image.Origin90!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.Image.Origin90! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineUIImageOrigin180Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.UI.Image.Origin180), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.UI.Image.Origin180), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.UI.Image.Origin180), L, null, 5, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Bottom", UnityEngine.UI.Image.Origin180.Bottom); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Left", UnityEngine.UI.Image.Origin180.Left); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Top", UnityEngine.UI.Image.Origin180.Top); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Right", UnityEngine.UI.Image.Origin180.Right); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.UI.Image.Origin180), 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.PushUnityEngineUIImageOrigin180(L, (UnityEngine.UI.Image.Origin180)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Bottom")) + { + translator.PushUnityEngineUIImageOrigin180(L, UnityEngine.UI.Image.Origin180.Bottom); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Left")) + { + translator.PushUnityEngineUIImageOrigin180(L, UnityEngine.UI.Image.Origin180.Left); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Top")) + { + translator.PushUnityEngineUIImageOrigin180(L, UnityEngine.UI.Image.Origin180.Top); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Right")) + { + translator.PushUnityEngineUIImageOrigin180(L, UnityEngine.UI.Image.Origin180.Right); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.Image.Origin180!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.Image.Origin180! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineUIImageOrigin360Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.UI.Image.Origin360), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.UI.Image.Origin360), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.UI.Image.Origin360), L, null, 5, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Bottom", UnityEngine.UI.Image.Origin360.Bottom); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Right", UnityEngine.UI.Image.Origin360.Right); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Top", UnityEngine.UI.Image.Origin360.Top); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Left", UnityEngine.UI.Image.Origin360.Left); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.UI.Image.Origin360), 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.PushUnityEngineUIImageOrigin360(L, (UnityEngine.UI.Image.Origin360)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Bottom")) + { + translator.PushUnityEngineUIImageOrigin360(L, UnityEngine.UI.Image.Origin360.Bottom); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Right")) + { + translator.PushUnityEngineUIImageOrigin360(L, UnityEngine.UI.Image.Origin360.Right); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Top")) + { + translator.PushUnityEngineUIImageOrigin360(L, UnityEngine.UI.Image.Origin360.Top); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Left")) + { + translator.PushUnityEngineUIImageOrigin360(L, UnityEngine.UI.Image.Origin360.Left); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.Image.Origin360!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.Image.Origin360! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineUIInputFieldContentTypeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.UI.InputField.ContentType), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.UI.InputField.ContentType), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.UI.InputField.ContentType), L, null, 11, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Standard", UnityEngine.UI.InputField.ContentType.Standard); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Autocorrected", UnityEngine.UI.InputField.ContentType.Autocorrected); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IntegerNumber", UnityEngine.UI.InputField.ContentType.IntegerNumber); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DecimalNumber", UnityEngine.UI.InputField.ContentType.DecimalNumber); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Alphanumeric", UnityEngine.UI.InputField.ContentType.Alphanumeric); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Name", UnityEngine.UI.InputField.ContentType.Name); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EmailAddress", UnityEngine.UI.InputField.ContentType.EmailAddress); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Password", UnityEngine.UI.InputField.ContentType.Password); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pin", UnityEngine.UI.InputField.ContentType.Pin); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Custom", UnityEngine.UI.InputField.ContentType.Custom); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.UI.InputField.ContentType), 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.PushUnityEngineUIInputFieldContentType(L, (UnityEngine.UI.InputField.ContentType)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Standard")) + { + translator.PushUnityEngineUIInputFieldContentType(L, UnityEngine.UI.InputField.ContentType.Standard); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Autocorrected")) + { + translator.PushUnityEngineUIInputFieldContentType(L, UnityEngine.UI.InputField.ContentType.Autocorrected); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "IntegerNumber")) + { + translator.PushUnityEngineUIInputFieldContentType(L, UnityEngine.UI.InputField.ContentType.IntegerNumber); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "DecimalNumber")) + { + translator.PushUnityEngineUIInputFieldContentType(L, UnityEngine.UI.InputField.ContentType.DecimalNumber); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Alphanumeric")) + { + translator.PushUnityEngineUIInputFieldContentType(L, UnityEngine.UI.InputField.ContentType.Alphanumeric); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Name")) + { + translator.PushUnityEngineUIInputFieldContentType(L, UnityEngine.UI.InputField.ContentType.Name); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "EmailAddress")) + { + translator.PushUnityEngineUIInputFieldContentType(L, UnityEngine.UI.InputField.ContentType.EmailAddress); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Password")) + { + translator.PushUnityEngineUIInputFieldContentType(L, UnityEngine.UI.InputField.ContentType.Password); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Pin")) + { + translator.PushUnityEngineUIInputFieldContentType(L, UnityEngine.UI.InputField.ContentType.Pin); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Custom")) + { + translator.PushUnityEngineUIInputFieldContentType(L, UnityEngine.UI.InputField.ContentType.Custom); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.InputField.ContentType!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.InputField.ContentType! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineUIInputFieldInputTypeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.UI.InputField.InputType), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.UI.InputField.InputType), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.UI.InputField.InputType), L, null, 4, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Standard", UnityEngine.UI.InputField.InputType.Standard); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AutoCorrect", UnityEngine.UI.InputField.InputType.AutoCorrect); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Password", UnityEngine.UI.InputField.InputType.Password); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.UI.InputField.InputType), 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.PushUnityEngineUIInputFieldInputType(L, (UnityEngine.UI.InputField.InputType)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Standard")) + { + translator.PushUnityEngineUIInputFieldInputType(L, UnityEngine.UI.InputField.InputType.Standard); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "AutoCorrect")) + { + translator.PushUnityEngineUIInputFieldInputType(L, UnityEngine.UI.InputField.InputType.AutoCorrect); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Password")) + { + translator.PushUnityEngineUIInputFieldInputType(L, UnityEngine.UI.InputField.InputType.Password); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.InputField.InputType!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.InputField.InputType! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineUIInputFieldCharacterValidationWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.UI.InputField.CharacterValidation), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.UI.InputField.CharacterValidation), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.UI.InputField.CharacterValidation), L, null, 7, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.UI.InputField.CharacterValidation.None); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Integer", UnityEngine.UI.InputField.CharacterValidation.Integer); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Decimal", UnityEngine.UI.InputField.CharacterValidation.Decimal); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Alphanumeric", UnityEngine.UI.InputField.CharacterValidation.Alphanumeric); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Name", UnityEngine.UI.InputField.CharacterValidation.Name); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EmailAddress", UnityEngine.UI.InputField.CharacterValidation.EmailAddress); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.UI.InputField.CharacterValidation), 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.PushUnityEngineUIInputFieldCharacterValidation(L, (UnityEngine.UI.InputField.CharacterValidation)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "None")) + { + translator.PushUnityEngineUIInputFieldCharacterValidation(L, UnityEngine.UI.InputField.CharacterValidation.None); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Integer")) + { + translator.PushUnityEngineUIInputFieldCharacterValidation(L, UnityEngine.UI.InputField.CharacterValidation.Integer); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Decimal")) + { + translator.PushUnityEngineUIInputFieldCharacterValidation(L, UnityEngine.UI.InputField.CharacterValidation.Decimal); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Alphanumeric")) + { + translator.PushUnityEngineUIInputFieldCharacterValidation(L, UnityEngine.UI.InputField.CharacterValidation.Alphanumeric); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Name")) + { + translator.PushUnityEngineUIInputFieldCharacterValidation(L, UnityEngine.UI.InputField.CharacterValidation.Name); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "EmailAddress")) + { + translator.PushUnityEngineUIInputFieldCharacterValidation(L, UnityEngine.UI.InputField.CharacterValidation.EmailAddress); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.InputField.CharacterValidation!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.InputField.CharacterValidation! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineUIInputFieldLineTypeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.UI.InputField.LineType), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.UI.InputField.LineType), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.UI.InputField.LineType), L, null, 4, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SingleLine", UnityEngine.UI.InputField.LineType.SingleLine); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MultiLineSubmit", UnityEngine.UI.InputField.LineType.MultiLineSubmit); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MultiLineNewline", UnityEngine.UI.InputField.LineType.MultiLineNewline); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.UI.InputField.LineType), 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.PushUnityEngineUIInputFieldLineType(L, (UnityEngine.UI.InputField.LineType)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "SingleLine")) + { + translator.PushUnityEngineUIInputFieldLineType(L, UnityEngine.UI.InputField.LineType.SingleLine); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "MultiLineSubmit")) + { + translator.PushUnityEngineUIInputFieldLineType(L, UnityEngine.UI.InputField.LineType.MultiLineSubmit); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "MultiLineNewline")) + { + translator.PushUnityEngineUIInputFieldLineType(L, UnityEngine.UI.InputField.LineType.MultiLineNewline); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.InputField.LineType!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.InputField.LineType! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineUIScrollRectMovementTypeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.UI.ScrollRect.MovementType), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.UI.ScrollRect.MovementType), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.UI.ScrollRect.MovementType), L, null, 4, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Unrestricted", UnityEngine.UI.ScrollRect.MovementType.Unrestricted); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Elastic", UnityEngine.UI.ScrollRect.MovementType.Elastic); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Clamped", UnityEngine.UI.ScrollRect.MovementType.Clamped); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.UI.ScrollRect.MovementType), 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.PushUnityEngineUIScrollRectMovementType(L, (UnityEngine.UI.ScrollRect.MovementType)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Unrestricted")) + { + translator.PushUnityEngineUIScrollRectMovementType(L, UnityEngine.UI.ScrollRect.MovementType.Unrestricted); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Elastic")) + { + translator.PushUnityEngineUIScrollRectMovementType(L, UnityEngine.UI.ScrollRect.MovementType.Elastic); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Clamped")) + { + translator.PushUnityEngineUIScrollRectMovementType(L, UnityEngine.UI.ScrollRect.MovementType.Clamped); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.ScrollRect.MovementType!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.ScrollRect.MovementType! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineUIScrollRectScrollbarVisibilityWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.UI.ScrollRect.ScrollbarVisibility), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.UI.ScrollRect.ScrollbarVisibility), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.UI.ScrollRect.ScrollbarVisibility), L, null, 4, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Permanent", UnityEngine.UI.ScrollRect.ScrollbarVisibility.Permanent); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AutoHide", UnityEngine.UI.ScrollRect.ScrollbarVisibility.AutoHide); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AutoHideAndExpandViewport", UnityEngine.UI.ScrollRect.ScrollbarVisibility.AutoHideAndExpandViewport); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.UI.ScrollRect.ScrollbarVisibility), 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.PushUnityEngineUIScrollRectScrollbarVisibility(L, (UnityEngine.UI.ScrollRect.ScrollbarVisibility)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Permanent")) + { + translator.PushUnityEngineUIScrollRectScrollbarVisibility(L, UnityEngine.UI.ScrollRect.ScrollbarVisibility.Permanent); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "AutoHide")) + { + translator.PushUnityEngineUIScrollRectScrollbarVisibility(L, UnityEngine.UI.ScrollRect.ScrollbarVisibility.AutoHide); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "AutoHideAndExpandViewport")) + { + translator.PushUnityEngineUIScrollRectScrollbarVisibility(L, UnityEngine.UI.ScrollRect.ScrollbarVisibility.AutoHideAndExpandViewport); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.ScrollRect.ScrollbarVisibility!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.ScrollRect.ScrollbarVisibility! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineUISliderDirectionWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.UI.Slider.Direction), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.UI.Slider.Direction), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.UI.Slider.Direction), L, null, 5, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LeftToRight", UnityEngine.UI.Slider.Direction.LeftToRight); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RightToLeft", UnityEngine.UI.Slider.Direction.RightToLeft); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BottomToTop", UnityEngine.UI.Slider.Direction.BottomToTop); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TopToBottom", UnityEngine.UI.Slider.Direction.TopToBottom); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.UI.Slider.Direction), 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.PushUnityEngineUISliderDirection(L, (UnityEngine.UI.Slider.Direction)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "LeftToRight")) + { + translator.PushUnityEngineUISliderDirection(L, UnityEngine.UI.Slider.Direction.LeftToRight); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "RightToLeft")) + { + translator.PushUnityEngineUISliderDirection(L, UnityEngine.UI.Slider.Direction.RightToLeft); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "BottomToTop")) + { + translator.PushUnityEngineUISliderDirection(L, UnityEngine.UI.Slider.Direction.BottomToTop); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "TopToBottom")) + { + translator.PushUnityEngineUISliderDirection(L, UnityEngine.UI.Slider.Direction.TopToBottom); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.Slider.Direction!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.Slider.Direction! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineUIToggleToggleTransitionWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.UI.Toggle.ToggleTransition), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.UI.Toggle.ToggleTransition), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.UI.Toggle.ToggleTransition), L, null, 3, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", UnityEngine.UI.Toggle.ToggleTransition.None); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fade", UnityEngine.UI.Toggle.ToggleTransition.Fade); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.UI.Toggle.ToggleTransition), 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.PushUnityEngineUIToggleToggleTransition(L, (UnityEngine.UI.Toggle.ToggleTransition)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "None")) + { + translator.PushUnityEngineUIToggleToggleTransition(L, UnityEngine.UI.Toggle.ToggleTransition.None); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Fade")) + { + translator.PushUnityEngineUIToggleToggleTransition(L, UnityEngine.UI.Toggle.ToggleTransition.Fade); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.Toggle.ToggleTransition!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.Toggle.ToggleTransition! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineUIGridLayoutGroupCornerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.UI.GridLayoutGroup.Corner), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.UI.GridLayoutGroup.Corner), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.UI.GridLayoutGroup.Corner), L, null, 5, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UpperLeft", UnityEngine.UI.GridLayoutGroup.Corner.UpperLeft); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UpperRight", UnityEngine.UI.GridLayoutGroup.Corner.UpperRight); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LowerLeft", UnityEngine.UI.GridLayoutGroup.Corner.LowerLeft); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LowerRight", UnityEngine.UI.GridLayoutGroup.Corner.LowerRight); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.UI.GridLayoutGroup.Corner), 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.PushUnityEngineUIGridLayoutGroupCorner(L, (UnityEngine.UI.GridLayoutGroup.Corner)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "UpperLeft")) + { + translator.PushUnityEngineUIGridLayoutGroupCorner(L, UnityEngine.UI.GridLayoutGroup.Corner.UpperLeft); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "UpperRight")) + { + translator.PushUnityEngineUIGridLayoutGroupCorner(L, UnityEngine.UI.GridLayoutGroup.Corner.UpperRight); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "LowerLeft")) + { + translator.PushUnityEngineUIGridLayoutGroupCorner(L, UnityEngine.UI.GridLayoutGroup.Corner.LowerLeft); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "LowerRight")) + { + translator.PushUnityEngineUIGridLayoutGroupCorner(L, UnityEngine.UI.GridLayoutGroup.Corner.LowerRight); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.GridLayoutGroup.Corner!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.GridLayoutGroup.Corner! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineUIGridLayoutGroupAxisWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.UI.GridLayoutGroup.Axis), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.UI.GridLayoutGroup.Axis), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.UI.GridLayoutGroup.Axis), L, null, 3, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Horizontal", UnityEngine.UI.GridLayoutGroup.Axis.Horizontal); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Vertical", UnityEngine.UI.GridLayoutGroup.Axis.Vertical); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.UI.GridLayoutGroup.Axis), 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.PushUnityEngineUIGridLayoutGroupAxis(L, (UnityEngine.UI.GridLayoutGroup.Axis)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Horizontal")) + { + translator.PushUnityEngineUIGridLayoutGroupAxis(L, UnityEngine.UI.GridLayoutGroup.Axis.Horizontal); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Vertical")) + { + translator.PushUnityEngineUIGridLayoutGroupAxis(L, UnityEngine.UI.GridLayoutGroup.Axis.Vertical); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.GridLayoutGroup.Axis!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.GridLayoutGroup.Axis! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEngineUIGridLayoutGroupConstraintWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.UI.GridLayoutGroup.Constraint), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.UI.GridLayoutGroup.Constraint), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.UI.GridLayoutGroup.Constraint), L, null, 4, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Flexible", UnityEngine.UI.GridLayoutGroup.Constraint.Flexible); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FixedColumnCount", UnityEngine.UI.GridLayoutGroup.Constraint.FixedColumnCount); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FixedRowCount", UnityEngine.UI.GridLayoutGroup.Constraint.FixedRowCount); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.UI.GridLayoutGroup.Constraint), 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.PushUnityEngineUIGridLayoutGroupConstraint(L, (UnityEngine.UI.GridLayoutGroup.Constraint)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Flexible")) + { + translator.PushUnityEngineUIGridLayoutGroupConstraint(L, UnityEngine.UI.GridLayoutGroup.Constraint.Flexible); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "FixedColumnCount")) + { + translator.PushUnityEngineUIGridLayoutGroupConstraint(L, UnityEngine.UI.GridLayoutGroup.Constraint.FixedColumnCount); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "FixedRowCount")) + { + translator.PushUnityEngineUIGridLayoutGroupConstraint(L, UnityEngine.UI.GridLayoutGroup.Constraint.FixedRowCount); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.UI.GridLayoutGroup.Constraint!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.UI.GridLayoutGroup.Constraint! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class SpineUnityBoneFollowerAxisOrientationWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(Spine.Unity.BoneFollower.AxisOrientation), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(Spine.Unity.BoneFollower.AxisOrientation), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(Spine.Unity.BoneFollower.AxisOrientation), L, null, 3, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "XAxis", Spine.Unity.BoneFollower.AxisOrientation.XAxis); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "YAxis", Spine.Unity.BoneFollower.AxisOrientation.YAxis); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(Spine.Unity.BoneFollower.AxisOrientation), 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.PushSpineUnityBoneFollowerAxisOrientation(L, (Spine.Unity.BoneFollower.AxisOrientation)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "XAxis")) + { + translator.PushSpineUnityBoneFollowerAxisOrientation(L, Spine.Unity.BoneFollower.AxisOrientation.XAxis); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "YAxis")) + { + translator.PushSpineUnityBoneFollowerAxisOrientation(L, Spine.Unity.BoneFollower.AxisOrientation.YAxis); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for Spine.Unity.BoneFollower.AxisOrientation!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for Spine.Unity.BoneFollower.AxisOrientation! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class SpineUnitySkeletonGraphicLayoutModeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(Spine.Unity.SkeletonGraphic.LayoutMode), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(Spine.Unity.SkeletonGraphic.LayoutMode), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(Spine.Unity.SkeletonGraphic.LayoutMode), L, null, 6, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", Spine.Unity.SkeletonGraphic.LayoutMode.None); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WidthControlsHeight", Spine.Unity.SkeletonGraphic.LayoutMode.WidthControlsHeight); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HeightControlsWidth", Spine.Unity.SkeletonGraphic.LayoutMode.HeightControlsWidth); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FitInParent", Spine.Unity.SkeletonGraphic.LayoutMode.FitInParent); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EnvelopeParent", Spine.Unity.SkeletonGraphic.LayoutMode.EnvelopeParent); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(Spine.Unity.SkeletonGraphic.LayoutMode), 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.PushSpineUnitySkeletonGraphicLayoutMode(L, (Spine.Unity.SkeletonGraphic.LayoutMode)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "None")) + { + translator.PushSpineUnitySkeletonGraphicLayoutMode(L, Spine.Unity.SkeletonGraphic.LayoutMode.None); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "WidthControlsHeight")) + { + translator.PushSpineUnitySkeletonGraphicLayoutMode(L, Spine.Unity.SkeletonGraphic.LayoutMode.WidthControlsHeight); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "HeightControlsWidth")) + { + translator.PushSpineUnitySkeletonGraphicLayoutMode(L, Spine.Unity.SkeletonGraphic.LayoutMode.HeightControlsWidth); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "FitInParent")) + { + translator.PushSpineUnitySkeletonGraphicLayoutMode(L, Spine.Unity.SkeletonGraphic.LayoutMode.FitInParent); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "EnvelopeParent")) + { + translator.PushSpineUnitySkeletonGraphicLayoutMode(L, Spine.Unity.SkeletonGraphic.LayoutMode.EnvelopeParent); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for Spine.Unity.SkeletonGraphic.LayoutMode!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for Spine.Unity.SkeletonGraphic.LayoutMode! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class TMProTextAlignmentOptionsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(TMPro.TextAlignmentOptions), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(TMPro.TextAlignmentOptions), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(TMPro.TextAlignmentOptions), L, null, 38, 0, 0); + + Utils.RegisterEnumType(L, typeof(TMPro.TextAlignmentOptions)); + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(TMPro.TextAlignmentOptions), 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.PushTMProTextAlignmentOptions(L, (TMPro.TextAlignmentOptions)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + try + { + translator.TranslateToEnumToTop(L, typeof(TMPro.TextAlignmentOptions), 1); + } + catch (System.Exception e) + { + return LuaAPI.luaL_error(L, "cast to " + typeof(TMPro.TextAlignmentOptions) + " exception:" + e); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for TMPro.TextAlignmentOptions! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class TMProTMP_InputFieldContentTypeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(TMPro.TMP_InputField.ContentType), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(TMPro.TMP_InputField.ContentType), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(TMPro.TMP_InputField.ContentType), L, null, 11, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Standard", TMPro.TMP_InputField.ContentType.Standard); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Autocorrected", TMPro.TMP_InputField.ContentType.Autocorrected); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IntegerNumber", TMPro.TMP_InputField.ContentType.IntegerNumber); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DecimalNumber", TMPro.TMP_InputField.ContentType.DecimalNumber); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Alphanumeric", TMPro.TMP_InputField.ContentType.Alphanumeric); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Name", TMPro.TMP_InputField.ContentType.Name); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EmailAddress", TMPro.TMP_InputField.ContentType.EmailAddress); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Password", TMPro.TMP_InputField.ContentType.Password); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pin", TMPro.TMP_InputField.ContentType.Pin); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Custom", TMPro.TMP_InputField.ContentType.Custom); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(TMPro.TMP_InputField.ContentType), 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.PushTMProTMP_InputFieldContentType(L, (TMPro.TMP_InputField.ContentType)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Standard")) + { + translator.PushTMProTMP_InputFieldContentType(L, TMPro.TMP_InputField.ContentType.Standard); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Autocorrected")) + { + translator.PushTMProTMP_InputFieldContentType(L, TMPro.TMP_InputField.ContentType.Autocorrected); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "IntegerNumber")) + { + translator.PushTMProTMP_InputFieldContentType(L, TMPro.TMP_InputField.ContentType.IntegerNumber); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "DecimalNumber")) + { + translator.PushTMProTMP_InputFieldContentType(L, TMPro.TMP_InputField.ContentType.DecimalNumber); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Alphanumeric")) + { + translator.PushTMProTMP_InputFieldContentType(L, TMPro.TMP_InputField.ContentType.Alphanumeric); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Name")) + { + translator.PushTMProTMP_InputFieldContentType(L, TMPro.TMP_InputField.ContentType.Name); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "EmailAddress")) + { + translator.PushTMProTMP_InputFieldContentType(L, TMPro.TMP_InputField.ContentType.EmailAddress); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Password")) + { + translator.PushTMProTMP_InputFieldContentType(L, TMPro.TMP_InputField.ContentType.Password); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Pin")) + { + translator.PushTMProTMP_InputFieldContentType(L, TMPro.TMP_InputField.ContentType.Pin); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Custom")) + { + translator.PushTMProTMP_InputFieldContentType(L, TMPro.TMP_InputField.ContentType.Custom); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for TMPro.TMP_InputField.ContentType!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for TMPro.TMP_InputField.ContentType! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class TMProTMP_InputFieldInputTypeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(TMPro.TMP_InputField.InputType), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(TMPro.TMP_InputField.InputType), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(TMPro.TMP_InputField.InputType), L, null, 4, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Standard", TMPro.TMP_InputField.InputType.Standard); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AutoCorrect", TMPro.TMP_InputField.InputType.AutoCorrect); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Password", TMPro.TMP_InputField.InputType.Password); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(TMPro.TMP_InputField.InputType), 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.PushTMProTMP_InputFieldInputType(L, (TMPro.TMP_InputField.InputType)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Standard")) + { + translator.PushTMProTMP_InputFieldInputType(L, TMPro.TMP_InputField.InputType.Standard); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "AutoCorrect")) + { + translator.PushTMProTMP_InputFieldInputType(L, TMPro.TMP_InputField.InputType.AutoCorrect); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Password")) + { + translator.PushTMProTMP_InputFieldInputType(L, TMPro.TMP_InputField.InputType.Password); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for TMPro.TMP_InputField.InputType!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for TMPro.TMP_InputField.InputType! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class TMProTMP_InputFieldCharacterValidationWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(TMPro.TMP_InputField.CharacterValidation), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(TMPro.TMP_InputField.CharacterValidation), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(TMPro.TMP_InputField.CharacterValidation), L, null, 10, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", TMPro.TMP_InputField.CharacterValidation.None); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Digit", TMPro.TMP_InputField.CharacterValidation.Digit); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Integer", TMPro.TMP_InputField.CharacterValidation.Integer); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Decimal", TMPro.TMP_InputField.CharacterValidation.Decimal); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Alphanumeric", TMPro.TMP_InputField.CharacterValidation.Alphanumeric); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Name", TMPro.TMP_InputField.CharacterValidation.Name); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Regex", TMPro.TMP_InputField.CharacterValidation.Regex); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EmailAddress", TMPro.TMP_InputField.CharacterValidation.EmailAddress); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CustomValidator", TMPro.TMP_InputField.CharacterValidation.CustomValidator); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(TMPro.TMP_InputField.CharacterValidation), 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.PushTMProTMP_InputFieldCharacterValidation(L, (TMPro.TMP_InputField.CharacterValidation)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "None")) + { + translator.PushTMProTMP_InputFieldCharacterValidation(L, TMPro.TMP_InputField.CharacterValidation.None); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Digit")) + { + translator.PushTMProTMP_InputFieldCharacterValidation(L, TMPro.TMP_InputField.CharacterValidation.Digit); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Integer")) + { + translator.PushTMProTMP_InputFieldCharacterValidation(L, TMPro.TMP_InputField.CharacterValidation.Integer); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Decimal")) + { + translator.PushTMProTMP_InputFieldCharacterValidation(L, TMPro.TMP_InputField.CharacterValidation.Decimal); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Alphanumeric")) + { + translator.PushTMProTMP_InputFieldCharacterValidation(L, TMPro.TMP_InputField.CharacterValidation.Alphanumeric); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Name")) + { + translator.PushTMProTMP_InputFieldCharacterValidation(L, TMPro.TMP_InputField.CharacterValidation.Name); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Regex")) + { + translator.PushTMProTMP_InputFieldCharacterValidation(L, TMPro.TMP_InputField.CharacterValidation.Regex); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "EmailAddress")) + { + translator.PushTMProTMP_InputFieldCharacterValidation(L, TMPro.TMP_InputField.CharacterValidation.EmailAddress); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "CustomValidator")) + { + translator.PushTMProTMP_InputFieldCharacterValidation(L, TMPro.TMP_InputField.CharacterValidation.CustomValidator); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for TMPro.TMP_InputField.CharacterValidation!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for TMPro.TMP_InputField.CharacterValidation! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class TMProTMP_InputFieldLineTypeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(TMPro.TMP_InputField.LineType), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(TMPro.TMP_InputField.LineType), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(TMPro.TMP_InputField.LineType), L, null, 4, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SingleLine", TMPro.TMP_InputField.LineType.SingleLine); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MultiLineSubmit", TMPro.TMP_InputField.LineType.MultiLineSubmit); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MultiLineNewline", TMPro.TMP_InputField.LineType.MultiLineNewline); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(TMPro.TMP_InputField.LineType), 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.PushTMProTMP_InputFieldLineType(L, (TMPro.TMP_InputField.LineType)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "SingleLine")) + { + translator.PushTMProTMP_InputFieldLineType(L, TMPro.TMP_InputField.LineType.SingleLine); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "MultiLineSubmit")) + { + translator.PushTMProTMP_InputFieldLineType(L, TMPro.TMP_InputField.LineType.MultiLineSubmit); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "MultiLineNewline")) + { + translator.PushTMProTMP_InputFieldLineType(L, TMPro.TMP_InputField.LineType.MultiLineNewline); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for TMPro.TMP_InputField.LineType!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for TMPro.TMP_InputField.LineType! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class ThinkingAnalyticsThinkingAnalyticsAPITATimeZoneWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone), L, null, 8, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Local", ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone.Local); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UTC", ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone.UTC); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Asia_Shanghai", ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone.Asia_Shanghai); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Asia_Tokyo", ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone.Asia_Tokyo); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "America_Los_Angeles", ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone.America_Los_Angeles); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "America_New_York", ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone.America_New_York); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Other", ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone.Other); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone), 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.PushThinkingAnalyticsThinkingAnalyticsAPITATimeZone(L, (ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Local")) + { + translator.PushThinkingAnalyticsThinkingAnalyticsAPITATimeZone(L, ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone.Local); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "UTC")) + { + translator.PushThinkingAnalyticsThinkingAnalyticsAPITATimeZone(L, ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone.UTC); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Asia_Shanghai")) + { + translator.PushThinkingAnalyticsThinkingAnalyticsAPITATimeZone(L, ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone.Asia_Shanghai); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Asia_Tokyo")) + { + translator.PushThinkingAnalyticsThinkingAnalyticsAPITATimeZone(L, ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone.Asia_Tokyo); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "America_Los_Angeles")) + { + translator.PushThinkingAnalyticsThinkingAnalyticsAPITATimeZone(L, ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone.America_Los_Angeles); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "America_New_York")) + { + translator.PushThinkingAnalyticsThinkingAnalyticsAPITATimeZone(L, ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone.America_New_York); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Other")) + { + translator.PushThinkingAnalyticsThinkingAnalyticsAPITATimeZone(L, ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone.Other); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class ThinkingAnalyticsThinkingAnalyticsAPITAModeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode), L, null, 4, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NORMAL", ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode.NORMAL); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DEBUG", ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode.DEBUG); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DEBUG_ONLY", ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode.DEBUG_ONLY); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode), 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.PushThinkingAnalyticsThinkingAnalyticsAPITAMode(L, (ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "NORMAL")) + { + translator.PushThinkingAnalyticsThinkingAnalyticsAPITAMode(L, ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode.NORMAL); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "DEBUG")) + { + translator.PushThinkingAnalyticsThinkingAnalyticsAPITAMode(L, ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode.DEBUG); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "DEBUG_ONLY")) + { + translator.PushThinkingAnalyticsThinkingAnalyticsAPITAMode(L, ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode.DEBUG_ONLY); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class ThinkingAnalyticsThinkingAnalyticsAPINetworkTypeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType), L, null, 4, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DEFAULT", ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType.DEFAULT); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WIFI", ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType.WIFI); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ALL", ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType.ALL); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType), 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.PushThinkingAnalyticsThinkingAnalyticsAPINetworkType(L, (ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "DEFAULT")) + { + translator.PushThinkingAnalyticsThinkingAnalyticsAPINetworkType(L, ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType.DEFAULT); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "WIFI")) + { + translator.PushThinkingAnalyticsThinkingAnalyticsAPINetworkType(L, ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType.WIFI); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "ALL")) + { + translator.PushThinkingAnalyticsThinkingAnalyticsAPINetworkType(L, ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType.ALL); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class DGTweeningAutoPlayWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(DG.Tweening.AutoPlay), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(DG.Tweening.AutoPlay), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(DG.Tweening.AutoPlay), L, null, 5, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", DG.Tweening.AutoPlay.None); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AutoPlaySequences", DG.Tweening.AutoPlay.AutoPlaySequences); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AutoPlayTweeners", DG.Tweening.AutoPlay.AutoPlayTweeners); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "All", DG.Tweening.AutoPlay.All); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(DG.Tweening.AutoPlay), 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.PushDGTweeningAutoPlay(L, (DG.Tweening.AutoPlay)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "None")) + { + translator.PushDGTweeningAutoPlay(L, DG.Tweening.AutoPlay.None); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "AutoPlaySequences")) + { + translator.PushDGTweeningAutoPlay(L, DG.Tweening.AutoPlay.AutoPlaySequences); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "AutoPlayTweeners")) + { + translator.PushDGTweeningAutoPlay(L, DG.Tweening.AutoPlay.AutoPlayTweeners); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "All")) + { + translator.PushDGTweeningAutoPlay(L, DG.Tweening.AutoPlay.All); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for DG.Tweening.AutoPlay!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for DG.Tweening.AutoPlay! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class DGTweeningAxisConstraintWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(DG.Tweening.AxisConstraint), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(DG.Tweening.AxisConstraint), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(DG.Tweening.AxisConstraint), L, null, 6, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", DG.Tweening.AxisConstraint.None); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "X", DG.Tweening.AxisConstraint.X); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Y", DG.Tweening.AxisConstraint.Y); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Z", DG.Tweening.AxisConstraint.Z); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "W", DG.Tweening.AxisConstraint.W); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(DG.Tweening.AxisConstraint), 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.PushDGTweeningAxisConstraint(L, (DG.Tweening.AxisConstraint)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "None")) + { + translator.PushDGTweeningAxisConstraint(L, DG.Tweening.AxisConstraint.None); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "X")) + { + translator.PushDGTweeningAxisConstraint(L, DG.Tweening.AxisConstraint.X); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Y")) + { + translator.PushDGTweeningAxisConstraint(L, DG.Tweening.AxisConstraint.Y); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Z")) + { + translator.PushDGTweeningAxisConstraint(L, DG.Tweening.AxisConstraint.Z); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "W")) + { + translator.PushDGTweeningAxisConstraint(L, DG.Tweening.AxisConstraint.W); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for DG.Tweening.AxisConstraint!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for DG.Tweening.AxisConstraint! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class DGTweeningEaseWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(DG.Tweening.Ease), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(DG.Tweening.Ease), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(DG.Tweening.Ease), L, null, 39, 0, 0); + + Utils.RegisterEnumType(L, typeof(DG.Tweening.Ease)); + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(DG.Tweening.Ease), 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.PushDGTweeningEase(L, (DG.Tweening.Ease)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + try + { + translator.TranslateToEnumToTop(L, typeof(DG.Tweening.Ease), 1); + } + catch (System.Exception e) + { + return LuaAPI.luaL_error(L, "cast to " + typeof(DG.Tweening.Ease) + " exception:" + e); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for DG.Tweening.Ease! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class DGTweeningLogBehaviourWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(DG.Tweening.LogBehaviour), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(DG.Tweening.LogBehaviour), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(DG.Tweening.LogBehaviour), L, null, 4, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Default", DG.Tweening.LogBehaviour.Default); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Verbose", DG.Tweening.LogBehaviour.Verbose); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ErrorsOnly", DG.Tweening.LogBehaviour.ErrorsOnly); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(DG.Tweening.LogBehaviour), 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.PushDGTweeningLogBehaviour(L, (DG.Tweening.LogBehaviour)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Default")) + { + translator.PushDGTweeningLogBehaviour(L, DG.Tweening.LogBehaviour.Default); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Verbose")) + { + translator.PushDGTweeningLogBehaviour(L, DG.Tweening.LogBehaviour.Verbose); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "ErrorsOnly")) + { + translator.PushDGTweeningLogBehaviour(L, DG.Tweening.LogBehaviour.ErrorsOnly); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for DG.Tweening.LogBehaviour!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for DG.Tweening.LogBehaviour! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class DGTweeningLoopTypeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(DG.Tweening.LoopType), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(DG.Tweening.LoopType), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(DG.Tweening.LoopType), L, null, 4, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Restart", DG.Tweening.LoopType.Restart); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Yoyo", DG.Tweening.LoopType.Yoyo); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Incremental", DG.Tweening.LoopType.Incremental); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(DG.Tweening.LoopType), 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.PushDGTweeningLoopType(L, (DG.Tweening.LoopType)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Restart")) + { + translator.PushDGTweeningLoopType(L, DG.Tweening.LoopType.Restart); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Yoyo")) + { + translator.PushDGTweeningLoopType(L, DG.Tweening.LoopType.Yoyo); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Incremental")) + { + translator.PushDGTweeningLoopType(L, DG.Tweening.LoopType.Incremental); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for DG.Tweening.LoopType!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for DG.Tweening.LoopType! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class DGTweeningPathModeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(DG.Tweening.PathMode), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(DG.Tweening.PathMode), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(DG.Tweening.PathMode), L, null, 5, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Ignore", DG.Tweening.PathMode.Ignore); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Full3D", DG.Tweening.PathMode.Full3D); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TopDown2D", DG.Tweening.PathMode.TopDown2D); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Sidescroller2D", DG.Tweening.PathMode.Sidescroller2D); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(DG.Tweening.PathMode), 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.PushDGTweeningPathMode(L, (DG.Tweening.PathMode)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Ignore")) + { + translator.PushDGTweeningPathMode(L, DG.Tweening.PathMode.Ignore); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Full3D")) + { + translator.PushDGTweeningPathMode(L, DG.Tweening.PathMode.Full3D); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "TopDown2D")) + { + translator.PushDGTweeningPathMode(L, DG.Tweening.PathMode.TopDown2D); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Sidescroller2D")) + { + translator.PushDGTweeningPathMode(L, DG.Tweening.PathMode.Sidescroller2D); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for DG.Tweening.PathMode!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for DG.Tweening.PathMode! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class DGTweeningPathTypeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(DG.Tweening.PathType), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(DG.Tweening.PathType), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(DG.Tweening.PathType), L, null, 4, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Linear", DG.Tweening.PathType.Linear); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CatmullRom", DG.Tweening.PathType.CatmullRom); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CubicBezier", DG.Tweening.PathType.CubicBezier); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(DG.Tweening.PathType), 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.PushDGTweeningPathType(L, (DG.Tweening.PathType)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Linear")) + { + translator.PushDGTweeningPathType(L, DG.Tweening.PathType.Linear); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "CatmullRom")) + { + translator.PushDGTweeningPathType(L, DG.Tweening.PathType.CatmullRom); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "CubicBezier")) + { + translator.PushDGTweeningPathType(L, DG.Tweening.PathType.CubicBezier); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for DG.Tweening.PathType!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for DG.Tweening.PathType! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class DGTweeningRotateModeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(DG.Tweening.RotateMode), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(DG.Tweening.RotateMode), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(DG.Tweening.RotateMode), L, null, 5, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fast", DG.Tweening.RotateMode.Fast); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FastBeyond360", DG.Tweening.RotateMode.FastBeyond360); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WorldAxisAdd", DG.Tweening.RotateMode.WorldAxisAdd); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LocalAxisAdd", DG.Tweening.RotateMode.LocalAxisAdd); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(DG.Tweening.RotateMode), 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.PushDGTweeningRotateMode(L, (DG.Tweening.RotateMode)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Fast")) + { + translator.PushDGTweeningRotateMode(L, DG.Tweening.RotateMode.Fast); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "FastBeyond360")) + { + translator.PushDGTweeningRotateMode(L, DG.Tweening.RotateMode.FastBeyond360); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "WorldAxisAdd")) + { + translator.PushDGTweeningRotateMode(L, DG.Tweening.RotateMode.WorldAxisAdd); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "LocalAxisAdd")) + { + translator.PushDGTweeningRotateMode(L, DG.Tweening.RotateMode.LocalAxisAdd); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for DG.Tweening.RotateMode!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for DG.Tweening.RotateMode! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class DGTweeningScrambleModeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(DG.Tweening.ScrambleMode), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(DG.Tweening.ScrambleMode), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(DG.Tweening.ScrambleMode), L, null, 7, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", DG.Tweening.ScrambleMode.None); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "All", DG.Tweening.ScrambleMode.All); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Uppercase", DG.Tweening.ScrambleMode.Uppercase); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Lowercase", DG.Tweening.ScrambleMode.Lowercase); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Numerals", DG.Tweening.ScrambleMode.Numerals); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Custom", DG.Tweening.ScrambleMode.Custom); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(DG.Tweening.ScrambleMode), 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.PushDGTweeningScrambleMode(L, (DG.Tweening.ScrambleMode)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "None")) + { + translator.PushDGTweeningScrambleMode(L, DG.Tweening.ScrambleMode.None); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "All")) + { + translator.PushDGTweeningScrambleMode(L, DG.Tweening.ScrambleMode.All); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Uppercase")) + { + translator.PushDGTweeningScrambleMode(L, DG.Tweening.ScrambleMode.Uppercase); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Lowercase")) + { + translator.PushDGTweeningScrambleMode(L, DG.Tweening.ScrambleMode.Lowercase); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Numerals")) + { + translator.PushDGTweeningScrambleMode(L, DG.Tweening.ScrambleMode.Numerals); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Custom")) + { + translator.PushDGTweeningScrambleMode(L, DG.Tweening.ScrambleMode.Custom); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for DG.Tweening.ScrambleMode!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for DG.Tweening.ScrambleMode! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class DGTweeningTweenTypeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(DG.Tweening.TweenType), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(DG.Tweening.TweenType), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(DG.Tweening.TweenType), L, null, 4, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Tweener", DG.Tweening.TweenType.Tweener); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Sequence", DG.Tweening.TweenType.Sequence); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Callback", DG.Tweening.TweenType.Callback); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(DG.Tweening.TweenType), 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.PushDGTweeningTweenType(L, (DG.Tweening.TweenType)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Tweener")) + { + translator.PushDGTweeningTweenType(L, DG.Tweening.TweenType.Tweener); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Sequence")) + { + translator.PushDGTweeningTweenType(L, DG.Tweening.TweenType.Sequence); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Callback")) + { + translator.PushDGTweeningTweenType(L, DG.Tweening.TweenType.Callback); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for DG.Tweening.TweenType!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for DG.Tweening.TweenType! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class DGTweeningUpdateTypeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(DG.Tweening.UpdateType), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(DG.Tweening.UpdateType), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(DG.Tweening.UpdateType), L, null, 5, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", DG.Tweening.UpdateType.Normal); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Late", DG.Tweening.UpdateType.Late); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fixed", DG.Tweening.UpdateType.Fixed); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Manual", DG.Tweening.UpdateType.Manual); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(DG.Tweening.UpdateType), 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.PushDGTweeningUpdateType(L, (DG.Tweening.UpdateType)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Normal")) + { + translator.PushDGTweeningUpdateType(L, DG.Tweening.UpdateType.Normal); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Late")) + { + translator.PushDGTweeningUpdateType(L, DG.Tweening.UpdateType.Late); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Fixed")) + { + translator.PushDGTweeningUpdateType(L, DG.Tweening.UpdateType.Fixed); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Manual")) + { + translator.PushDGTweeningUpdateType(L, DG.Tweening.UpdateType.Manual); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for DG.Tweening.UpdateType!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for DG.Tweening.UpdateType! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class HttpRequestStateWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(Http.RequestState), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(Http.RequestState), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(Http.RequestState), L, null, 4, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Success", Http.RequestState.Success); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Aborted", Http.RequestState.Aborted); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fail", Http.RequestState.Fail); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(Http.RequestState), 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.PushHttpRequestState(L, (Http.RequestState)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Success")) + { + translator.PushHttpRequestState(L, Http.RequestState.Success); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Aborted")) + { + translator.PushHttpRequestState(L, Http.RequestState.Aborted); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Fail")) + { + translator.PushHttpRequestState(L, Http.RequestState.Fail); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for Http.RequestState!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for Http.RequestState! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class UnityEnginePurchasingProductTypeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(UnityEngine.Purchasing.ProductType), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(UnityEngine.Purchasing.ProductType), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(UnityEngine.Purchasing.ProductType), L, null, 4, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Consumable", UnityEngine.Purchasing.ProductType.Consumable); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NonConsumable", UnityEngine.Purchasing.ProductType.NonConsumable); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Subscription", UnityEngine.Purchasing.ProductType.Subscription); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(UnityEngine.Purchasing.ProductType), 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.PushUnityEnginePurchasingProductType(L, (UnityEngine.Purchasing.ProductType)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Consumable")) + { + translator.PushUnityEnginePurchasingProductType(L, UnityEngine.Purchasing.ProductType.Consumable); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "NonConsumable")) + { + translator.PushUnityEnginePurchasingProductType(L, UnityEngine.Purchasing.ProductType.NonConsumable); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Subscription")) + { + translator.PushUnityEnginePurchasingProductType(L, UnityEngine.Purchasing.ProductType.Subscription); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for UnityEngine.Purchasing.ProductType!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for UnityEngine.Purchasing.ProductType! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class BFBFSliderFillDirectionWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(BF.BFSlider.FillDirection), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(BF.BFSlider.FillDirection), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(BF.BFSlider.FillDirection), L, null, 5, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Right", BF.BFSlider.FillDirection.Right); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Left", BF.BFSlider.FillDirection.Left); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Up", BF.BFSlider.FillDirection.Up); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Down", BF.BFSlider.FillDirection.Down); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(BF.BFSlider.FillDirection), 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.PushBFBFSliderFillDirection(L, (BF.BFSlider.FillDirection)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Right")) + { + translator.PushBFBFSliderFillDirection(L, BF.BFSlider.FillDirection.Right); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Left")) + { + translator.PushBFBFSliderFillDirection(L, BF.BFSlider.FillDirection.Left); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Up")) + { + translator.PushBFBFSliderFillDirection(L, BF.BFSlider.FillDirection.Up); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Down")) + { + translator.PushBFBFSliderFillDirection(L, BF.BFSlider.FillDirection.Down); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for BF.BFSlider.FillDirection!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for BF.BFSlider.FillDirection! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class BFScrollRectBaseOldMovementTypeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(BF.ScrollRectBaseOld.MovementType), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(BF.ScrollRectBaseOld.MovementType), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(BF.ScrollRectBaseOld.MovementType), L, null, 4, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Unrestricted", BF.ScrollRectBaseOld.MovementType.Unrestricted); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Elastic", BF.ScrollRectBaseOld.MovementType.Elastic); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Clamped", BF.ScrollRectBaseOld.MovementType.Clamped); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(BF.ScrollRectBaseOld.MovementType), 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.PushBFScrollRectBaseOldMovementType(L, (BF.ScrollRectBaseOld.MovementType)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Unrestricted")) + { + translator.PushBFScrollRectBaseOldMovementType(L, BF.ScrollRectBaseOld.MovementType.Unrestricted); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Elastic")) + { + translator.PushBFScrollRectBaseOldMovementType(L, BF.ScrollRectBaseOld.MovementType.Elastic); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Clamped")) + { + translator.PushBFScrollRectBaseOldMovementType(L, BF.ScrollRectBaseOld.MovementType.Clamped); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for BF.ScrollRectBaseOld.MovementType!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for BF.ScrollRectBaseOld.MovementType! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class BFScrollRectBaseOldScrollbarVisibilityWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(BF.ScrollRectBaseOld.ScrollbarVisibility), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(BF.ScrollRectBaseOld.ScrollbarVisibility), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(BF.ScrollRectBaseOld.ScrollbarVisibility), L, null, 4, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Permanent", BF.ScrollRectBaseOld.ScrollbarVisibility.Permanent); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AutoHide", BF.ScrollRectBaseOld.ScrollbarVisibility.AutoHide); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AutoHideAndExpandViewport", BF.ScrollRectBaseOld.ScrollbarVisibility.AutoHideAndExpandViewport); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(BF.ScrollRectBaseOld.ScrollbarVisibility), 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.PushBFScrollRectBaseOldScrollbarVisibility(L, (BF.ScrollRectBaseOld.ScrollbarVisibility)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Permanent")) + { + translator.PushBFScrollRectBaseOldScrollbarVisibility(L, BF.ScrollRectBaseOld.ScrollbarVisibility.Permanent); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "AutoHide")) + { + translator.PushBFScrollRectBaseOldScrollbarVisibility(L, BF.ScrollRectBaseOld.ScrollbarVisibility.AutoHide); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "AutoHideAndExpandViewport")) + { + translator.PushBFScrollRectBaseOldScrollbarVisibility(L, BF.ScrollRectBaseOld.ScrollbarVisibility.AutoHideAndExpandViewport); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for BF.ScrollRectBaseOld.ScrollbarVisibility!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for BF.ScrollRectBaseOld.ScrollbarVisibility! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class BFNetServiceTypeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(BF.NetServiceType), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(BF.NetServiceType), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(BF.NetServiceType), L, null, 5, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Invalid", BF.NetServiceType.Invalid); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TCPService", BF.NetServiceType.TCPService); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UDPService", BF.NetServiceType.UDPService); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WebsocketService", BF.NetServiceType.WebsocketService); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(BF.NetServiceType), 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.PushBFNetServiceType(L, (BF.NetServiceType)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Invalid")) + { + translator.PushBFNetServiceType(L, BF.NetServiceType.Invalid); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "TCPService")) + { + translator.PushBFNetServiceType(L, BF.NetServiceType.TCPService); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "UDPService")) + { + translator.PushBFNetServiceType(L, BF.NetServiceType.UDPService); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "WebsocketService")) + { + translator.PushBFNetServiceType(L, BF.NetServiceType.WebsocketService); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for BF.NetServiceType!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for BF.NetServiceType! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class BFNetIncomingMessageTypeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(BF.NetIncomingMessageType), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(BF.NetIncomingMessageType), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(BF.NetIncomingMessageType), L, null, 8, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Error", BF.NetIncomingMessageType.Error); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StatusChange", BF.NetIncomingMessageType.StatusChange); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Data", BF.NetIncomingMessageType.Data); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DebugMessage", BF.NetIncomingMessageType.DebugMessage); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WarningMessage", BF.NetIncomingMessageType.WarningMessage); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ErrorMessage", BF.NetIncomingMessageType.ErrorMessage); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HeartBeatMessage", BF.NetIncomingMessageType.HeartBeatMessage); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(BF.NetIncomingMessageType), 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.PushBFNetIncomingMessageType(L, (BF.NetIncomingMessageType)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Error")) + { + translator.PushBFNetIncomingMessageType(L, BF.NetIncomingMessageType.Error); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "StatusChange")) + { + translator.PushBFNetIncomingMessageType(L, BF.NetIncomingMessageType.StatusChange); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Data")) + { + translator.PushBFNetIncomingMessageType(L, BF.NetIncomingMessageType.Data); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "DebugMessage")) + { + translator.PushBFNetIncomingMessageType(L, BF.NetIncomingMessageType.DebugMessage); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "WarningMessage")) + { + translator.PushBFNetIncomingMessageType(L, BF.NetIncomingMessageType.WarningMessage); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "ErrorMessage")) + { + translator.PushBFNetIncomingMessageType(L, BF.NetIncomingMessageType.ErrorMessage); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "HeartBeatMessage")) + { + translator.PushBFNetIncomingMessageType(L, BF.NetIncomingMessageType.HeartBeatMessage); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for BF.NetIncomingMessageType!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for BF.NetIncomingMessageType! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class BFTouchEventTypeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(BF.TouchEventType), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(BF.TouchEventType), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(BF.TouchEventType), L, null, 7, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Down", BF.TouchEventType.Down); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Touching", BF.TouchEventType.Touching); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Up", BF.TouchEventType.Up); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Hit", BF.TouchEventType.Hit); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Slide", BF.TouchEventType.Slide); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Dead", BF.TouchEventType.Dead); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(BF.TouchEventType), 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.PushBFTouchEventType(L, (BF.TouchEventType)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "Down")) + { + translator.PushBFTouchEventType(L, BF.TouchEventType.Down); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Touching")) + { + translator.PushBFTouchEventType(L, BF.TouchEventType.Touching); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Up")) + { + translator.PushBFTouchEventType(L, BF.TouchEventType.Up); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Hit")) + { + translator.PushBFTouchEventType(L, BF.TouchEventType.Hit); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Slide")) + { + translator.PushBFTouchEventType(L, BF.TouchEventType.Slide); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "Dead")) + { + translator.PushBFTouchEventType(L, BF.TouchEventType.Dead); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for BF.TouchEventType!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for BF.TouchEventType! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + + public class BFSelectEventTypeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + Utils.BeginObjectRegister(typeof(BF.SelectEventType), L, translator, 0, 0, 0, 0); + Utils.EndObjectRegister(typeof(BF.SelectEventType), L, translator, null, null, null, null, null); + + Utils.BeginClassRegister(typeof(BF.SelectEventType), L, null, 6, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OnSelect", BF.SelectEventType.OnSelect); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OnLongSelected", BF.SelectEventType.OnLongSelected); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OnDeselect", BF.SelectEventType.OnDeselect); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OnLongDeselect", BF.SelectEventType.OnLongDeselect); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OnSelectHit", BF.SelectEventType.OnSelectHit); + + + Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom); + + Utils.EndClassRegister(typeof(BF.SelectEventType), 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.PushBFSelectEventType(L, (BF.SelectEventType)LuaAPI.xlua_tointeger(L, 1)); + } + + else if(lua_type == LuaTypes.LUA_TSTRING) + { + + if (LuaAPI.xlua_is_eq_str(L, 1, "OnSelect")) + { + translator.PushBFSelectEventType(L, BF.SelectEventType.OnSelect); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "OnLongSelected")) + { + translator.PushBFSelectEventType(L, BF.SelectEventType.OnLongSelected); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "OnDeselect")) + { + translator.PushBFSelectEventType(L, BF.SelectEventType.OnDeselect); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "OnLongDeselect")) + { + translator.PushBFSelectEventType(L, BF.SelectEventType.OnLongDeselect); + } + else if (LuaAPI.xlua_is_eq_str(L, 1, "OnSelectHit")) + { + translator.PushBFSelectEventType(L, BF.SelectEventType.OnSelectHit); + } + else + { + return LuaAPI.luaL_error(L, "invalid string for BF.SelectEventType!"); + } + + } + + else + { + return LuaAPI.luaL_error(L, "invalid lua type for BF.SelectEventType! Expect number or string, got + " + lua_type); + } + + return 1; + } + } + +} \ No newline at end of file diff --git a/Assets/XLua/Gen/FBWindowsA2UNotificationsManagerWrap.cs b/Assets/XLua/Gen/FBWindowsA2UNotificationsManagerWrap.cs new file mode 100644 index 000000000..7efb5165a --- /dev/null +++ b/Assets/XLua/Gen/FBWindowsA2UNotificationsManagerWrap.cs @@ -0,0 +1,298 @@ +#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 FBWindowsA2UNotificationsManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(FBWindowsA2UNotificationsManager); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 6, 6); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ScheduleButton", _m_ScheduleButton); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Logger", _g_get_Logger); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "TitleText", _g_get_TitleText); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "BodyText", _g_get_BodyText); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "MediaText", _g_get_MediaText); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PayloadText", _g_get_PayloadText); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "TimeIntervalText", _g_get_TimeIntervalText); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Logger", _s_set_Logger); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "TitleText", _s_set_TitleText); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "BodyText", _s_set_BodyText); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "MediaText", _s_set_MediaText); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "PayloadText", _s_set_PayloadText); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "TimeIntervalText", _s_set_TimeIntervalText); + + + 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 FBWindowsA2UNotificationsManager(); + 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 FBWindowsA2UNotificationsManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ScheduleButton(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsA2UNotificationsManager gen_to_be_invoked = (FBWindowsA2UNotificationsManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ScheduleButton( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Logger(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsA2UNotificationsManager gen_to_be_invoked = (FBWindowsA2UNotificationsManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Logger); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_TitleText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsA2UNotificationsManager gen_to_be_invoked = (FBWindowsA2UNotificationsManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.TitleText); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_BodyText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsA2UNotificationsManager gen_to_be_invoked = (FBWindowsA2UNotificationsManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.BodyText); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_MediaText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsA2UNotificationsManager gen_to_be_invoked = (FBWindowsA2UNotificationsManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.MediaText); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PayloadText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsA2UNotificationsManager gen_to_be_invoked = (FBWindowsA2UNotificationsManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.PayloadText); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_TimeIntervalText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsA2UNotificationsManager gen_to_be_invoked = (FBWindowsA2UNotificationsManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.TimeIntervalText); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Logger(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsA2UNotificationsManager gen_to_be_invoked = (FBWindowsA2UNotificationsManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Logger = (FBWindowsLogsManager)translator.GetObject(L, 2, typeof(FBWindowsLogsManager)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_TitleText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsA2UNotificationsManager gen_to_be_invoked = (FBWindowsA2UNotificationsManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.TitleText = (UnityEngine.UI.InputField)translator.GetObject(L, 2, typeof(UnityEngine.UI.InputField)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_BodyText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsA2UNotificationsManager gen_to_be_invoked = (FBWindowsA2UNotificationsManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.BodyText = (UnityEngine.UI.InputField)translator.GetObject(L, 2, typeof(UnityEngine.UI.InputField)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_MediaText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsA2UNotificationsManager gen_to_be_invoked = (FBWindowsA2UNotificationsManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.MediaText = (UnityEngine.UI.InputField)translator.GetObject(L, 2, typeof(UnityEngine.UI.InputField)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_PayloadText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsA2UNotificationsManager gen_to_be_invoked = (FBWindowsA2UNotificationsManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.PayloadText = (UnityEngine.UI.InputField)translator.GetObject(L, 2, typeof(UnityEngine.UI.InputField)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_TimeIntervalText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsA2UNotificationsManager gen_to_be_invoked = (FBWindowsA2UNotificationsManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.TimeIntervalText = (UnityEngine.UI.InputField)translator.GetObject(L, 2, typeof(UnityEngine.UI.InputField)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/FBWindowsADSManagerWrap.cs b/Assets/XLua/Gen/FBWindowsADSManagerWrap.cs new file mode 100644 index 000000000..8107151a2 --- /dev/null +++ b/Assets/XLua/Gen/FBWindowsADSManagerWrap.cs @@ -0,0 +1,405 @@ +#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 FBWindowsADSManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(FBWindowsADSManager); + Utils.BeginObjectRegister(type, L, translator, 0, 8, 3, 3); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadRewardedVideo", _m_LoadRewardedVideo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ShowRewardedVideo", _m_ShowRewardedVideo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadInterstitialAd", _m_LoadInterstitialAd); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ShowInterstitialAd", _m_ShowInterstitialAd); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnButtonLoadInterstitialAd", _m_OnButtonLoadInterstitialAd); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnButtonShowInterstitialAd", _m_OnButtonShowInterstitialAd); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnButtonLoadRewardedVideo", _m_OnButtonLoadRewardedVideo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnButtonShowRewardedVideo", _m_OnButtonShowRewardedVideo); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Logger", _g_get_Logger); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "InputInterstitialAd", _g_get_InputInterstitialAd); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "InputRewardedVideo", _g_get_InputRewardedVideo); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Logger", _s_set_Logger); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "InputInterstitialAd", _s_set_InputInterstitialAd); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "InputRewardedVideo", _s_set_InputRewardedVideo); + + + 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 FBWindowsADSManager(); + 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 FBWindowsADSManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadRewardedVideo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsADSManager gen_to_be_invoked = (FBWindowsADSManager)translator.FastGetCSObj(L, 1); + + + + { + string _placementID = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.LoadRewardedVideo( _placementID ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ShowRewardedVideo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsADSManager gen_to_be_invoked = (FBWindowsADSManager)translator.FastGetCSObj(L, 1); + + + + { + string _placementID = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.ShowRewardedVideo( _placementID ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadInterstitialAd(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsADSManager gen_to_be_invoked = (FBWindowsADSManager)translator.FastGetCSObj(L, 1); + + + + { + string _placementID = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.LoadInterstitialAd( _placementID ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ShowInterstitialAd(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsADSManager gen_to_be_invoked = (FBWindowsADSManager)translator.FastGetCSObj(L, 1); + + + + { + string _placementID = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.ShowInterstitialAd( _placementID ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnButtonLoadInterstitialAd(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsADSManager gen_to_be_invoked = (FBWindowsADSManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.OnButtonLoadInterstitialAd( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnButtonShowInterstitialAd(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsADSManager gen_to_be_invoked = (FBWindowsADSManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.OnButtonShowInterstitialAd( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnButtonLoadRewardedVideo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsADSManager gen_to_be_invoked = (FBWindowsADSManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.OnButtonLoadRewardedVideo( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnButtonShowRewardedVideo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsADSManager gen_to_be_invoked = (FBWindowsADSManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.OnButtonShowRewardedVideo( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Logger(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsADSManager gen_to_be_invoked = (FBWindowsADSManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Logger); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_InputInterstitialAd(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsADSManager gen_to_be_invoked = (FBWindowsADSManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.InputInterstitialAd); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_InputRewardedVideo(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsADSManager gen_to_be_invoked = (FBWindowsADSManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.InputRewardedVideo); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Logger(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsADSManager gen_to_be_invoked = (FBWindowsADSManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Logger = (FBWindowsLogsManager)translator.GetObject(L, 2, typeof(FBWindowsLogsManager)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_InputInterstitialAd(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsADSManager gen_to_be_invoked = (FBWindowsADSManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.InputInterstitialAd = (UnityEngine.UI.InputField)translator.GetObject(L, 2, typeof(UnityEngine.UI.InputField)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_InputRewardedVideo(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsADSManager gen_to_be_invoked = (FBWindowsADSManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.InputRewardedVideo = (UnityEngine.UI.InputField)translator.GetObject(L, 2, typeof(UnityEngine.UI.InputField)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/FBWindowsExampleTabsManagerWrap.cs b/Assets/XLua/Gen/FBWindowsExampleTabsManagerWrap.cs new file mode 100644 index 000000000..1e1715bf8 --- /dev/null +++ b/Assets/XLua/Gen/FBWindowsExampleTabsManagerWrap.cs @@ -0,0 +1,144 @@ +#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 FBWindowsExampleTabsManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(FBWindowsExampleTabsManager); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 1, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ShowTab", _m_ShowTab); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sections", _g_get_sections); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sections", _s_set_sections); + + + 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 FBWindowsExampleTabsManager(); + 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 FBWindowsExampleTabsManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ShowTab(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsExampleTabsManager gen_to_be_invoked = (FBWindowsExampleTabsManager)translator.FastGetCSObj(L, 1); + + + + { + int _id = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.ShowTab( _id ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sections(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsExampleTabsManager gen_to_be_invoked = (FBWindowsExampleTabsManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.sections); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_sections(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsExampleTabsManager gen_to_be_invoked = (FBWindowsExampleTabsManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.sections = (UnityEngine.GameObject[])translator.GetObject(L, 2, typeof(UnityEngine.GameObject[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/FBWindowsFriendsManagerWrap.cs b/Assets/XLua/Gen/FBWindowsFriendsManagerWrap.cs new file mode 100644 index 000000000..6e7101f88 --- /dev/null +++ b/Assets/XLua/Gen/FBWindowsFriendsManagerWrap.cs @@ -0,0 +1,233 @@ +#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 FBWindowsFriendsManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(FBWindowsFriendsManager); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 3, 3); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Button_OpenReceivedInvitations", _m_Button_OpenReceivedInvitations); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Button_GetFriendFinderInvitations", _m_Button_GetFriendFinderInvitations); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Logger", _g_get_Logger); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ReceivedInvitationsPanelTransform", _g_get_ReceivedInvitationsPanelTransform); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ShowReceivedInvitation", _g_get_ShowReceivedInvitation); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Logger", _s_set_Logger); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ReceivedInvitationsPanelTransform", _s_set_ReceivedInvitationsPanelTransform); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ShowReceivedInvitation", _s_set_ShowReceivedInvitation); + + + 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 FBWindowsFriendsManager(); + 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 FBWindowsFriendsManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Button_OpenReceivedInvitations(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsFriendsManager gen_to_be_invoked = (FBWindowsFriendsManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Button_OpenReceivedInvitations( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Button_GetFriendFinderInvitations(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsFriendsManager gen_to_be_invoked = (FBWindowsFriendsManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Button_GetFriendFinderInvitations( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Logger(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsFriendsManager gen_to_be_invoked = (FBWindowsFriendsManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Logger); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ReceivedInvitationsPanelTransform(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsFriendsManager gen_to_be_invoked = (FBWindowsFriendsManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.ReceivedInvitationsPanelTransform); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ShowReceivedInvitation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsFriendsManager gen_to_be_invoked = (FBWindowsFriendsManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.ShowReceivedInvitation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Logger(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsFriendsManager gen_to_be_invoked = (FBWindowsFriendsManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Logger = (FBWindowsLogsManager)translator.GetObject(L, 2, typeof(FBWindowsLogsManager)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_ReceivedInvitationsPanelTransform(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsFriendsManager gen_to_be_invoked = (FBWindowsFriendsManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ReceivedInvitationsPanelTransform = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_ShowReceivedInvitation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsFriendsManager gen_to_be_invoked = (FBWindowsFriendsManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ShowReceivedInvitation = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/FBWindowsGraphAPIManagerWrap.cs b/Assets/XLua/Gen/FBWindowsGraphAPIManagerWrap.cs new file mode 100644 index 000000000..24c766e82 --- /dev/null +++ b/Assets/XLua/Gen/FBWindowsGraphAPIManagerWrap.cs @@ -0,0 +1,295 @@ +#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 FBWindowsGraphAPIManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(FBWindowsGraphAPIManager); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 5, 5); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GraphAPI", _m_GraphAPI); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetGraphAPiVersion", _m_SetGraphAPiVersion); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Logger", _g_get_Logger); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "QueryText", _g_get_QueryText); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "QueryType", _g_get_QueryType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "GraphAPIVersionText", _g_get_GraphAPIVersionText); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "GraphAPIVersion", _g_get_GraphAPIVersion); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Logger", _s_set_Logger); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "QueryText", _s_set_QueryText); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "QueryType", _s_set_QueryType); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "GraphAPIVersionText", _s_set_GraphAPIVersionText); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "GraphAPIVersion", _s_set_GraphAPIVersion); + + + 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 FBWindowsGraphAPIManager(); + 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 FBWindowsGraphAPIManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GraphAPI(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsGraphAPIManager gen_to_be_invoked = (FBWindowsGraphAPIManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.GraphAPI( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetGraphAPiVersion(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsGraphAPIManager gen_to_be_invoked = (FBWindowsGraphAPIManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetGraphAPiVersion( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Logger(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsGraphAPIManager gen_to_be_invoked = (FBWindowsGraphAPIManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Logger); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_QueryText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsGraphAPIManager gen_to_be_invoked = (FBWindowsGraphAPIManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.QueryText); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_QueryType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsGraphAPIManager gen_to_be_invoked = (FBWindowsGraphAPIManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.QueryType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_GraphAPIVersionText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsGraphAPIManager gen_to_be_invoked = (FBWindowsGraphAPIManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.GraphAPIVersionText); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_GraphAPIVersion(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsGraphAPIManager gen_to_be_invoked = (FBWindowsGraphAPIManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.GraphAPIVersion); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Logger(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsGraphAPIManager gen_to_be_invoked = (FBWindowsGraphAPIManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Logger = (FBWindowsLogsManager)translator.GetObject(L, 2, typeof(FBWindowsLogsManager)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_QueryText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsGraphAPIManager gen_to_be_invoked = (FBWindowsGraphAPIManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.QueryText = (UnityEngine.UI.InputField)translator.GetObject(L, 2, typeof(UnityEngine.UI.InputField)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_QueryType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsGraphAPIManager gen_to_be_invoked = (FBWindowsGraphAPIManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.QueryType = (UnityEngine.UI.Dropdown)translator.GetObject(L, 2, typeof(UnityEngine.UI.Dropdown)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_GraphAPIVersionText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsGraphAPIManager gen_to_be_invoked = (FBWindowsGraphAPIManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.GraphAPIVersionText = (UnityEngine.UI.InputField)translator.GetObject(L, 2, typeof(UnityEngine.UI.InputField)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_GraphAPIVersion(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsGraphAPIManager gen_to_be_invoked = (FBWindowsGraphAPIManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.GraphAPIVersion = (UnityEngine.UI.Text)translator.GetObject(L, 2, typeof(UnityEngine.UI.Text)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/FBWindowsInitManagerWrap.cs b/Assets/XLua/Gen/FBWindowsInitManagerWrap.cs new file mode 100644 index 000000000..8ed78d1c8 --- /dev/null +++ b/Assets/XLua/Gen/FBWindowsInitManagerWrap.cs @@ -0,0 +1,143 @@ +#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 FBWindowsInitManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(FBWindowsInitManager); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 1, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InitButton", _m_InitButton); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Logger", _g_get_Logger); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Logger", _s_set_Logger); + + + 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 FBWindowsInitManager(); + 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 FBWindowsInitManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_InitButton(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsInitManager gen_to_be_invoked = (FBWindowsInitManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.InitButton( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Logger(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsInitManager gen_to_be_invoked = (FBWindowsInitManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Logger); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Logger(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsInitManager gen_to_be_invoked = (FBWindowsInitManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Logger = (FBWindowsLogsManager)translator.GetObject(L, 2, typeof(FBWindowsLogsManager)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/FBWindowsLoginManagerWrap.cs b/Assets/XLua/Gen/FBWindowsLoginManagerWrap.cs new file mode 100644 index 000000000..d2bb27705 --- /dev/null +++ b/Assets/XLua/Gen/FBWindowsLoginManagerWrap.cs @@ -0,0 +1,348 @@ +#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 FBWindowsLoginManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(FBWindowsLoginManager); + Utils.BeginObjectRegister(type, L, translator, 0, 5, 4, 4); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LogInReadButton", _m_LogInReadButton); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LogInPublishButton", _m_LogInPublishButton); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LogOutButton", _m_LogOutButton); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetCurrentProfile", _m_GetCurrentProfile); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetUserLocale", _m_GetUserLocale); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Logger", _g_get_Logger); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Permissions", _g_get_Permissions); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "UserImage", _g_get_UserImage); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "UserName", _g_get_UserName); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Logger", _s_set_Logger); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Permissions", _s_set_Permissions); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "UserImage", _s_set_UserImage); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "UserName", _s_set_UserName); + + + 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 FBWindowsLoginManager(); + 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 FBWindowsLoginManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LogInReadButton(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsLoginManager gen_to_be_invoked = (FBWindowsLoginManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.LogInReadButton( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LogInPublishButton(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsLoginManager gen_to_be_invoked = (FBWindowsLoginManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.LogInPublishButton( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LogOutButton(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsLoginManager gen_to_be_invoked = (FBWindowsLoginManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.LogOutButton( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetCurrentProfile(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsLoginManager gen_to_be_invoked = (FBWindowsLoginManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.GetCurrentProfile( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetUserLocale(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsLoginManager gen_to_be_invoked = (FBWindowsLoginManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.GetUserLocale( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Logger(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsLoginManager gen_to_be_invoked = (FBWindowsLoginManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Logger); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Permissions(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsLoginManager gen_to_be_invoked = (FBWindowsLoginManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Permissions); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UserImage(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsLoginManager gen_to_be_invoked = (FBWindowsLoginManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.UserImage); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UserName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsLoginManager gen_to_be_invoked = (FBWindowsLoginManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.UserName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Logger(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsLoginManager gen_to_be_invoked = (FBWindowsLoginManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Logger = (FBWindowsLogsManager)translator.GetObject(L, 2, typeof(FBWindowsLogsManager)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Permissions(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsLoginManager gen_to_be_invoked = (FBWindowsLoginManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Permissions = (UnityEngine.UI.InputField)translator.GetObject(L, 2, typeof(UnityEngine.UI.InputField)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_UserImage(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsLoginManager gen_to_be_invoked = (FBWindowsLoginManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.UserImage = (UnityEngine.UI.RawImage)translator.GetObject(L, 2, typeof(UnityEngine.UI.RawImage)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_UserName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsLoginManager gen_to_be_invoked = (FBWindowsLoginManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.UserName = (UnityEngine.UI.Text)translator.GetObject(L, 2, typeof(UnityEngine.UI.Text)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/FBWindowsLogsManagerWrap.cs b/Assets/XLua/Gen/FBWindowsLogsManagerWrap.cs new file mode 100644 index 000000000..df959440a --- /dev/null +++ b/Assets/XLua/Gen/FBWindowsLogsManagerWrap.cs @@ -0,0 +1,261 @@ +#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 FBWindowsLogsManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(FBWindowsLogsManager); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 2, 2); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DebugLog", _m_DebugLog); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DebugErrorLog", _m_DebugErrorLog); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DebugWarningLog", _m_DebugWarningLog); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DebugClean", _m_DebugClean); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "LogText", _g_get_LogText); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ScrollView", _g_get_ScrollView); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "LogText", _s_set_LogText); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ScrollView", _s_set_ScrollView); + + + 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 FBWindowsLogsManager(); + 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 FBWindowsLogsManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DebugLog(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsLogsManager gen_to_be_invoked = (FBWindowsLogsManager)translator.FastGetCSObj(L, 1); + + + + { + string _message = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.DebugLog( _message ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DebugErrorLog(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsLogsManager gen_to_be_invoked = (FBWindowsLogsManager)translator.FastGetCSObj(L, 1); + + + + { + string _message = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.DebugErrorLog( _message ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DebugWarningLog(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsLogsManager gen_to_be_invoked = (FBWindowsLogsManager)translator.FastGetCSObj(L, 1); + + + + { + string _message = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.DebugWarningLog( _message ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DebugClean(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsLogsManager gen_to_be_invoked = (FBWindowsLogsManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.DebugClean( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_LogText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsLogsManager gen_to_be_invoked = (FBWindowsLogsManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.LogText); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ScrollView(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsLogsManager gen_to_be_invoked = (FBWindowsLogsManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.ScrollView); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_LogText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsLogsManager gen_to_be_invoked = (FBWindowsLogsManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.LogText = (UnityEngine.UI.Text)translator.GetObject(L, 2, typeof(UnityEngine.UI.Text)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_ScrollView(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsLogsManager gen_to_be_invoked = (FBWindowsLogsManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ScrollView = (UnityEngine.UI.ScrollRect)translator.GetObject(L, 2, typeof(UnityEngine.UI.ScrollRect)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/FBWindowsPhysicalGamepadManagerWrap.cs b/Assets/XLua/Gen/FBWindowsPhysicalGamepadManagerWrap.cs new file mode 100644 index 000000000..69cdd735c --- /dev/null +++ b/Assets/XLua/Gen/FBWindowsPhysicalGamepadManagerWrap.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 FBWindowsPhysicalGamepadManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(FBWindowsPhysicalGamepadManager); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 1, 1); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "displayGamepadInputText", _g_get_displayGamepadInputText); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "displayGamepadInputText", _s_set_displayGamepadInputText); + + + 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 FBWindowsPhysicalGamepadManager(); + 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 FBWindowsPhysicalGamepadManager constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_displayGamepadInputText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsPhysicalGamepadManager gen_to_be_invoked = (FBWindowsPhysicalGamepadManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.displayGamepadInputText); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_displayGamepadInputText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsPhysicalGamepadManager gen_to_be_invoked = (FBWindowsPhysicalGamepadManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.displayGamepadInputText = (UnityEngine.UI.Text)translator.GetObject(L, 2, typeof(UnityEngine.UI.Text)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/FBWindowsPurchaseManagerWrap.cs b/Assets/XLua/Gen/FBWindowsPurchaseManagerWrap.cs new file mode 100644 index 000000000..55068dfa4 --- /dev/null +++ b/Assets/XLua/Gen/FBWindowsPurchaseManagerWrap.cs @@ -0,0 +1,264 @@ +#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 FBWindowsPurchaseManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(FBWindowsPurchaseManager); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 4, 4); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetCatalogButton", _m_GetCatalogButton); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPurchases", _m_GetPurchases); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Logger", _g_get_Logger); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ProductGameObject", _g_get_ProductGameObject); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "CatalogPanelTarnsform", _g_get_CatalogPanelTarnsform); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PurchasesPanelTarnsform", _g_get_PurchasesPanelTarnsform); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Logger", _s_set_Logger); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ProductGameObject", _s_set_ProductGameObject); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "CatalogPanelTarnsform", _s_set_CatalogPanelTarnsform); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "PurchasesPanelTarnsform", _s_set_PurchasesPanelTarnsform); + + + 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 FBWindowsPurchaseManager(); + 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 FBWindowsPurchaseManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetCatalogButton(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsPurchaseManager gen_to_be_invoked = (FBWindowsPurchaseManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.GetCatalogButton( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetPurchases(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsPurchaseManager gen_to_be_invoked = (FBWindowsPurchaseManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.GetPurchases( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Logger(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsPurchaseManager gen_to_be_invoked = (FBWindowsPurchaseManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Logger); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ProductGameObject(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsPurchaseManager gen_to_be_invoked = (FBWindowsPurchaseManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.ProductGameObject); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_CatalogPanelTarnsform(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsPurchaseManager gen_to_be_invoked = (FBWindowsPurchaseManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.CatalogPanelTarnsform); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PurchasesPanelTarnsform(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsPurchaseManager gen_to_be_invoked = (FBWindowsPurchaseManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.PurchasesPanelTarnsform); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Logger(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsPurchaseManager gen_to_be_invoked = (FBWindowsPurchaseManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Logger = (FBWindowsLogsManager)translator.GetObject(L, 2, typeof(FBWindowsLogsManager)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_ProductGameObject(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsPurchaseManager gen_to_be_invoked = (FBWindowsPurchaseManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ProductGameObject = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_CatalogPanelTarnsform(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsPurchaseManager gen_to_be_invoked = (FBWindowsPurchaseManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.CatalogPanelTarnsform = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_PurchasesPanelTarnsform(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsPurchaseManager gen_to_be_invoked = (FBWindowsPurchaseManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.PurchasesPanelTarnsform = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/FBWindowsShareManagerWrap.cs b/Assets/XLua/Gen/FBWindowsShareManagerWrap.cs new file mode 100644 index 000000000..27d4fdf05 --- /dev/null +++ b/Assets/XLua/Gen/FBWindowsShareManagerWrap.cs @@ -0,0 +1,388 @@ +#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 FBWindowsShareManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(FBWindowsShareManager); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 8, 8); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Button_UploadImage", _m_Button_UploadImage); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Button_UploadVideo", _m_Button_UploadVideo); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Logger", _g_get_Logger); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Caption", _g_get_Caption); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ImageFile", _g_get_ImageFile); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "VideoFile", _g_get_VideoFile); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "TravelID", _g_get_TravelID); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ShouldShowDialog", _g_get_ShouldShowDialog); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ImageUploadButton", _g_get_ImageUploadButton); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "VideoUploadButton", _g_get_VideoUploadButton); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Logger", _s_set_Logger); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Caption", _s_set_Caption); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ImageFile", _s_set_ImageFile); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "VideoFile", _s_set_VideoFile); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "TravelID", _s_set_TravelID); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ShouldShowDialog", _s_set_ShouldShowDialog); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ImageUploadButton", _s_set_ImageUploadButton); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "VideoUploadButton", _s_set_VideoUploadButton); + + + 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 FBWindowsShareManager(); + 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 FBWindowsShareManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Button_UploadImage(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsShareManager gen_to_be_invoked = (FBWindowsShareManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Button_UploadImage( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Button_UploadVideo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsShareManager gen_to_be_invoked = (FBWindowsShareManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Button_UploadVideo( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Logger(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsShareManager gen_to_be_invoked = (FBWindowsShareManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Logger); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Caption(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsShareManager gen_to_be_invoked = (FBWindowsShareManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Caption); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ImageFile(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsShareManager gen_to_be_invoked = (FBWindowsShareManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.ImageFile); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_VideoFile(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsShareManager gen_to_be_invoked = (FBWindowsShareManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.VideoFile); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_TravelID(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsShareManager gen_to_be_invoked = (FBWindowsShareManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.TravelID); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ShouldShowDialog(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsShareManager gen_to_be_invoked = (FBWindowsShareManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.ShouldShowDialog); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ImageUploadButton(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsShareManager gen_to_be_invoked = (FBWindowsShareManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.ImageUploadButton); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_VideoUploadButton(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsShareManager gen_to_be_invoked = (FBWindowsShareManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.VideoUploadButton); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Logger(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsShareManager gen_to_be_invoked = (FBWindowsShareManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Logger = (FBWindowsLogsManager)translator.GetObject(L, 2, typeof(FBWindowsLogsManager)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Caption(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsShareManager gen_to_be_invoked = (FBWindowsShareManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Caption = (UnityEngine.UI.InputField)translator.GetObject(L, 2, typeof(UnityEngine.UI.InputField)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_ImageFile(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsShareManager gen_to_be_invoked = (FBWindowsShareManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ImageFile = (UnityEngine.UI.InputField)translator.GetObject(L, 2, typeof(UnityEngine.UI.InputField)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_VideoFile(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsShareManager gen_to_be_invoked = (FBWindowsShareManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.VideoFile = (UnityEngine.UI.InputField)translator.GetObject(L, 2, typeof(UnityEngine.UI.InputField)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_TravelID(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsShareManager gen_to_be_invoked = (FBWindowsShareManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.TravelID = (UnityEngine.UI.InputField)translator.GetObject(L, 2, typeof(UnityEngine.UI.InputField)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_ShouldShowDialog(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsShareManager gen_to_be_invoked = (FBWindowsShareManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ShouldShowDialog = (UnityEngine.UI.Toggle)translator.GetObject(L, 2, typeof(UnityEngine.UI.Toggle)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_ImageUploadButton(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsShareManager gen_to_be_invoked = (FBWindowsShareManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ImageUploadButton = (UnityEngine.UI.Button)translator.GetObject(L, 2, typeof(UnityEngine.UI.Button)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_VideoUploadButton(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsShareManager gen_to_be_invoked = (FBWindowsShareManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.VideoUploadButton = (UnityEngine.UI.Button)translator.GetObject(L, 2, typeof(UnityEngine.UI.Button)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/FBWindowsSoftKeyboardManagerWrap.cs b/Assets/XLua/Gen/FBWindowsSoftKeyboardManagerWrap.cs new file mode 100644 index 000000000..1379f991f --- /dev/null +++ b/Assets/XLua/Gen/FBWindowsSoftKeyboardManagerWrap.cs @@ -0,0 +1,143 @@ +#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 FBWindowsSoftKeyboardManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(FBWindowsSoftKeyboardManager); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 1, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSoftKeyboardOpenButton", _m_SetSoftKeyboardOpenButton); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Logger", _g_get_Logger); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Logger", _s_set_Logger); + + + 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 FBWindowsSoftKeyboardManager(); + 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 FBWindowsSoftKeyboardManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSoftKeyboardOpenButton(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsSoftKeyboardManager gen_to_be_invoked = (FBWindowsSoftKeyboardManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetSoftKeyboardOpenButton( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Logger(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsSoftKeyboardManager gen_to_be_invoked = (FBWindowsSoftKeyboardManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Logger); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Logger(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsSoftKeyboardManager gen_to_be_invoked = (FBWindowsSoftKeyboardManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Logger = (FBWindowsLogsManager)translator.GetObject(L, 2, typeof(FBWindowsLogsManager)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/FBWindowsTournamentsManagerWrap.cs b/Assets/XLua/Gen/FBWindowsTournamentsManagerWrap.cs new file mode 100644 index 000000000..234fd0529 --- /dev/null +++ b/Assets/XLua/Gen/FBWindowsTournamentsManagerWrap.cs @@ -0,0 +1,503 @@ +#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 FBWindowsTournamentsManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(FBWindowsTournamentsManager); + Utils.BeginObjectRegister(type, L, translator, 0, 5, 9, 9); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Button_CreateTournament", _m_Button_CreateTournament); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Button_PostSessionScore", _m_Button_PostSessionScore); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Button_PostTournamentScore", _m_Button_PostTournamentScore); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Button_ShareTournament", _m_Button_ShareTournament); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Button_GetTournament", _m_Button_GetTournament); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Logger", _g_get_Logger); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Title", _g_get_Title); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Image", _g_get_Image); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "SortOrder", _g_get_SortOrder); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ScoreFormat", _g_get_ScoreFormat); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Data", _g_get_Data); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "InitialScore", _g_get_InitialScore); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Score", _g_get_Score); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ShareData", _g_get_ShareData); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Logger", _s_set_Logger); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Title", _s_set_Title); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Image", _s_set_Image); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "SortOrder", _s_set_SortOrder); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ScoreFormat", _s_set_ScoreFormat); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Data", _s_set_Data); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "InitialScore", _s_set_InitialScore); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Score", _s_set_Score); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ShareData", _s_set_ShareData); + + + 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 FBWindowsTournamentsManager(); + 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 FBWindowsTournamentsManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Button_CreateTournament(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsTournamentsManager gen_to_be_invoked = (FBWindowsTournamentsManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Button_CreateTournament( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Button_PostSessionScore(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsTournamentsManager gen_to_be_invoked = (FBWindowsTournamentsManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Button_PostSessionScore( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Button_PostTournamentScore(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsTournamentsManager gen_to_be_invoked = (FBWindowsTournamentsManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Button_PostTournamentScore( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Button_ShareTournament(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsTournamentsManager gen_to_be_invoked = (FBWindowsTournamentsManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Button_ShareTournament( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Button_GetTournament(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsTournamentsManager gen_to_be_invoked = (FBWindowsTournamentsManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Button_GetTournament( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Logger(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsTournamentsManager gen_to_be_invoked = (FBWindowsTournamentsManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Logger); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Title(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsTournamentsManager gen_to_be_invoked = (FBWindowsTournamentsManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Title); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Image(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsTournamentsManager gen_to_be_invoked = (FBWindowsTournamentsManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Image); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_SortOrder(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsTournamentsManager gen_to_be_invoked = (FBWindowsTournamentsManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.SortOrder); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ScoreFormat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsTournamentsManager gen_to_be_invoked = (FBWindowsTournamentsManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.ScoreFormat); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Data(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsTournamentsManager gen_to_be_invoked = (FBWindowsTournamentsManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Data); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_InitialScore(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsTournamentsManager gen_to_be_invoked = (FBWindowsTournamentsManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.InitialScore); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Score(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsTournamentsManager gen_to_be_invoked = (FBWindowsTournamentsManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Score); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ShareData(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsTournamentsManager gen_to_be_invoked = (FBWindowsTournamentsManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.ShareData); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Logger(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsTournamentsManager gen_to_be_invoked = (FBWindowsTournamentsManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Logger = (FBWindowsLogsManager)translator.GetObject(L, 2, typeof(FBWindowsLogsManager)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Title(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsTournamentsManager gen_to_be_invoked = (FBWindowsTournamentsManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Title = (UnityEngine.UI.InputField)translator.GetObject(L, 2, typeof(UnityEngine.UI.InputField)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Image(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsTournamentsManager gen_to_be_invoked = (FBWindowsTournamentsManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Image = (UnityEngine.UI.InputField)translator.GetObject(L, 2, typeof(UnityEngine.UI.InputField)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_SortOrder(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsTournamentsManager gen_to_be_invoked = (FBWindowsTournamentsManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.SortOrder = (UnityEngine.UI.Dropdown)translator.GetObject(L, 2, typeof(UnityEngine.UI.Dropdown)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_ScoreFormat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsTournamentsManager gen_to_be_invoked = (FBWindowsTournamentsManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ScoreFormat = (UnityEngine.UI.Dropdown)translator.GetObject(L, 2, typeof(UnityEngine.UI.Dropdown)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Data(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsTournamentsManager gen_to_be_invoked = (FBWindowsTournamentsManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Data = (UnityEngine.UI.InputField)translator.GetObject(L, 2, typeof(UnityEngine.UI.InputField)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_InitialScore(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsTournamentsManager gen_to_be_invoked = (FBWindowsTournamentsManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.InitialScore = (UnityEngine.UI.InputField)translator.GetObject(L, 2, typeof(UnityEngine.UI.InputField)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Score(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsTournamentsManager gen_to_be_invoked = (FBWindowsTournamentsManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Score = (UnityEngine.UI.InputField)translator.GetObject(L, 2, typeof(UnityEngine.UI.InputField)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_ShareData(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsTournamentsManager gen_to_be_invoked = (FBWindowsTournamentsManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ShareData = (UnityEngine.UI.InputField)translator.GetObject(L, 2, typeof(UnityEngine.UI.InputField)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/FBWindowsVirtualGamepadManagerWrap.cs b/Assets/XLua/Gen/FBWindowsVirtualGamepadManagerWrap.cs new file mode 100644 index 000000000..5cc95b60a --- /dev/null +++ b/Assets/XLua/Gen/FBWindowsVirtualGamepadManagerWrap.cs @@ -0,0 +1,174 @@ +#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 FBWindowsVirtualGamepadManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(FBWindowsVirtualGamepadManager); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 2, 2); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetVirtualGamepadLayout", _m_SetVirtualGamepadLayout); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Logger", _g_get_Logger); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "NewVirtualGamepadLayout", _g_get_NewVirtualGamepadLayout); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Logger", _s_set_Logger); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "NewVirtualGamepadLayout", _s_set_NewVirtualGamepadLayout); + + + 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 FBWindowsVirtualGamepadManager(); + 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 FBWindowsVirtualGamepadManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetVirtualGamepadLayout(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FBWindowsVirtualGamepadManager gen_to_be_invoked = (FBWindowsVirtualGamepadManager)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetVirtualGamepadLayout( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Logger(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsVirtualGamepadManager gen_to_be_invoked = (FBWindowsVirtualGamepadManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Logger); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_NewVirtualGamepadLayout(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsVirtualGamepadManager gen_to_be_invoked = (FBWindowsVirtualGamepadManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.NewVirtualGamepadLayout); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Logger(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsVirtualGamepadManager gen_to_be_invoked = (FBWindowsVirtualGamepadManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Logger = (FBWindowsLogsManager)translator.GetObject(L, 2, typeof(FBWindowsLogsManager)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_NewVirtualGamepadLayout(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FBWindowsVirtualGamepadManager gen_to_be_invoked = (FBWindowsVirtualGamepadManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.NewVirtualGamepadLayout = (UnityEngine.UI.InputField)translator.GetObject(L, 2, typeof(UnityEngine.UI.InputField)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/Facebook_MiniJSON_JsonWrap.cs b/Assets/XLua/Gen/Facebook_MiniJSON_JsonWrap.cs new file mode 100644 index 000000000..ea2713440 --- /dev/null +++ b/Assets/XLua/Gen/Facebook_MiniJSON_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 FacebookMiniJSONJsonWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(Facebook.MiniJSON.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, "Facebook.MiniJSON.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 = Facebook.MiniJSON.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 = Facebook.MiniJSON.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/Facebook_MiniJSON_MiniJsonUtilWrap.cs b/Assets/XLua/Gen/Facebook_MiniJSON_MiniJsonUtilWrap.cs new file mode 100644 index 000000000..7ec5d95d5 --- /dev/null +++ b/Assets/XLua/Gen/Facebook_MiniJSON_MiniJsonUtilWrap.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 FacebookMiniJSONMiniJsonUtilWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(Facebook.MiniJSON.MiniJsonUtil); + 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, "Facebook.MiniJSON.MiniJsonUtil does not have a constructor!"); + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/FixRectWidthByStringWrap.cs b/Assets/XLua/Gen/FixRectWidthByStringWrap.cs new file mode 100644 index 000000000..0f42674dc --- /dev/null +++ b/Assets/XLua/Gen/FixRectWidthByStringWrap.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 FixRectWidthByStringWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(FixRectWidthByString); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 1, 1); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "minWidth", _g_get_minWidth); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "minWidth", _s_set_minWidth); + + + 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 FixRectWidthByString(); + 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 FixRectWidthByString constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_minWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FixRectWidthByString gen_to_be_invoked = (FixRectWidthByString)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.minWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_minWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + FixRectWidthByString gen_to_be_invoked = (FixRectWidthByString)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.minWidth = 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/FunctionRequestWrap.cs b/Assets/XLua/Gen/FunctionRequestWrap.cs new file mode 100644 index 000000000..55979fed4 --- /dev/null +++ b/Assets/XLua/Gen/FunctionRequestWrap.cs @@ -0,0 +1,128 @@ +#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 FunctionRequestWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(FunctionRequest); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Invoke", _m_Invoke); + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 1, 0); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "Instance", _g_get_Instance); + + + + 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 FunctionRequest(); + 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 FunctionRequest constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Invoke(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + FunctionRequest gen_to_be_invoked = (FunctionRequest)translator.FastGetCSObj(L, 1); + + + + { + string _method = LuaAPI.lua_tostring(L, 2); + string _body = LuaAPI.lua_tostring(L, 3); + System.Action _complete = translator.GetDelegate>(L, 4); + + gen_to_be_invoked.Invoke( _method, _body, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Instance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, FunctionRequest.Instance); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/Http_HttpDebugWrap.cs b/Assets/XLua/Gen/Http_HttpDebugWrap.cs new file mode 100644 index 000000000..4be7f61c5 --- /dev/null +++ b/Assets/XLua/Gen/Http_HttpDebugWrap.cs @@ -0,0 +1,142 @@ +#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 HttpHttpDebugWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(Http.HttpDebug); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 4, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Log", _m_Log_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.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "Http.HttpDebug does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Log_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _msg = LuaAPI.lua_tostring(L, 1); + + Http.HttpDebug.Log( _msg ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LogError_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _msg = LuaAPI.lua_tostring(L, 1); + + Http.HttpDebug.LogError( _msg ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LogWarning_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _msg = LuaAPI.lua_tostring(L, 1); + + Http.HttpDebug.LogWarning( _msg ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/Http_HttpManagerWrap.cs b/Assets/XLua/Gen/Http_HttpManagerWrap.cs new file mode 100644 index 000000000..e37e14d38 --- /dev/null +++ b/Assets/XLua/Gen/Http_HttpManagerWrap.cs @@ -0,0 +1,468 @@ +#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 HttpHttpManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(Http.HttpManager); + Utils.BeginObjectRegister(type, L, translator, 0, 12, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetServerUrl", _m_SetServerUrl); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetToken", _m_SetToken); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetParseRevocableSession", _m_SetParseRevocableSession); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetParseApplicationId", _m_SetParseApplicationId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetParseClientKey", _m_SetParseClientKey); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetParseClientPlatform", _m_SetParseClientPlatform); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetParseClientVersion", _m_SetParseClientVersion); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Get", _m_Get); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Post", _m_Post); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Put", _m_Put); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Delete", _m_Delete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Abort", _m_Abort); + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 1, 0); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "Instance", _g_get_Instance); + + + + 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 Http.HttpManager(); + 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 Http.HttpManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetServerUrl(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Http.HttpManager gen_to_be_invoked = (Http.HttpManager)translator.FastGetCSObj(L, 1); + + + + { + string _url = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SetServerUrl( _url ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetToken(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Http.HttpManager gen_to_be_invoked = (Http.HttpManager)translator.FastGetCSObj(L, 1); + + + + { + string _token = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SetToken( _token ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetParseRevocableSession(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Http.HttpManager gen_to_be_invoked = (Http.HttpManager)translator.FastGetCSObj(L, 1); + + + + { + string _key = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SetParseRevocableSession( _key ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetParseApplicationId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Http.HttpManager gen_to_be_invoked = (Http.HttpManager)translator.FastGetCSObj(L, 1); + + + + { + string _appId = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SetParseApplicationId( _appId ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetParseClientKey(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Http.HttpManager gen_to_be_invoked = (Http.HttpManager)translator.FastGetCSObj(L, 1); + + + + { + string _key = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SetParseClientKey( _key ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetParseClientPlatform(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Http.HttpManager gen_to_be_invoked = (Http.HttpManager)translator.FastGetCSObj(L, 1); + + + + { + string _key = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SetParseClientPlatform( _key ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetParseClientVersion(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Http.HttpManager gen_to_be_invoked = (Http.HttpManager)translator.FastGetCSObj(L, 1); + + + + { + string _key = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SetParseClientVersion( _key ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Get(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Http.HttpManager gen_to_be_invoked = (Http.HttpManager)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _id = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.Get( _id ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 3)) + { + string _url = LuaAPI.lua_tostring(L, 2); + System.Action _complete = translator.GetDelegate>(L, 3); + + var gen_ret = gen_to_be_invoked.Get( _url, _complete ); + 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 Http.HttpManager.Get!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Post(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Http.HttpManager gen_to_be_invoked = (Http.HttpManager)translator.FastGetCSObj(L, 1); + + + + { + string _url = LuaAPI.lua_tostring(L, 2); + System.Action _complete = translator.GetDelegate>(L, 3); + + var gen_ret = gen_to_be_invoked.Post( _url, _complete ); + 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_Put(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Http.HttpManager gen_to_be_invoked = (Http.HttpManager)translator.FastGetCSObj(L, 1); + + + + { + string _url = LuaAPI.lua_tostring(L, 2); + System.Action _complete = translator.GetDelegate>(L, 3); + + var gen_ret = gen_to_be_invoked.Put( _url, _complete ); + 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_Delete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Http.HttpManager gen_to_be_invoked = (Http.HttpManager)translator.FastGetCSObj(L, 1); + + + + { + string _url = LuaAPI.lua_tostring(L, 2); + System.Action _complete = translator.GetDelegate>(L, 3); + + var gen_ret = gen_to_be_invoked.Delete( _url, _complete ); + 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_Abort(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Http.HttpManager gen_to_be_invoked = (Http.HttpManager)translator.FastGetCSObj(L, 1); + + + + { + string _id = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.Abort( _id ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Instance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, Http.HttpManager.Instance); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/Http_RequestDataWrap.cs b/Assets/XLua/Gen/Http_RequestDataWrap.cs new file mode 100644 index 000000000..9d9bd7078 --- /dev/null +++ b/Assets/XLua/Gen/Http_RequestDataWrap.cs @@ -0,0 +1,146 @@ +#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 HttpRequestDataWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(Http.RequestData); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 2); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "code", _g_get_code); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "error", _g_get_error); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "code", _s_set_code); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "error", _s_set_error); + + + 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 Http.RequestData(); + 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 Http.RequestData constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_code(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Http.RequestData gen_to_be_invoked = (Http.RequestData)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.code); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_error(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Http.RequestData gen_to_be_invoked = (Http.RequestData)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.error); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_code(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Http.RequestData gen_to_be_invoked = (Http.RequestData)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.code = 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_error(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Http.RequestData gen_to_be_invoked = (Http.RequestData)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.error = 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/Http_ResultInfoWrap.cs b/Assets/XLua/Gen/Http_ResultInfoWrap.cs new file mode 100644 index 000000000..38797111f --- /dev/null +++ b/Assets/XLua/Gen/Http_ResultInfoWrap.cs @@ -0,0 +1,209 @@ +#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 HttpResultInfoWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(Http.ResultInfo); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 4, 4); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Id", _g_get_Id); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Tag", _g_get_Tag); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "State", _g_get_State); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Response", _g_get_Response); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Id", _s_set_Id); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Tag", _s_set_Tag); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "State", _s_set_State); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Response", _s_set_Response); + + + 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 Http.ResultInfo(); + 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 Http.ResultInfo constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Id(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Http.ResultInfo gen_to_be_invoked = (Http.ResultInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Id); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Tag(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Http.ResultInfo gen_to_be_invoked = (Http.ResultInfo)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.Tag); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_State(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Http.ResultInfo gen_to_be_invoked = (Http.ResultInfo)translator.FastGetCSObj(L, 1); + translator.PushHttpRequestState(L, gen_to_be_invoked.State); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Response(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Http.ResultInfo gen_to_be_invoked = (Http.ResultInfo)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Response); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Id(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Http.ResultInfo gen_to_be_invoked = (Http.ResultInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Id = 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_Tag(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Http.ResultInfo gen_to_be_invoked = (Http.ResultInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Tag = translator.GetObject(L, 2, typeof(object)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_State(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Http.ResultInfo gen_to_be_invoked = (Http.ResultInfo)translator.FastGetCSObj(L, 1); + Http.RequestState gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.State = 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_Response(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Http.ResultInfo gen_to_be_invoked = (Http.ResultInfo)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Response = (BestHTTP.HTTPResponse)translator.GetObject(L, 2, typeof(BestHTTP.HTTPResponse)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/Http_SingleHttpExtendsWrap.cs b/Assets/XLua/Gen/Http_SingleHttpExtendsWrap.cs new file mode 100644 index 000000000..b65445f9e --- /dev/null +++ b/Assets/XLua/Gen/Http_SingleHttpExtendsWrap.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 HttpSingleHttpExtendsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(Http.SingleHttpExtends); + 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, "Http.SingleHttpExtends does not have a constructor!"); + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/Http_SingleHttpWrap.cs b/Assets/XLua/Gen/Http_SingleHttpWrap.cs new file mode 100644 index 000000000..e50980a56 --- /dev/null +++ b/Assets/XLua/Gen/Http_SingleHttpWrap.cs @@ -0,0 +1,666 @@ +#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; +using Http; + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class HttpSingleHttpWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(Http.SingleHttp); + Utils.BeginObjectRegister(type, L, translator, 0, 13, 5, 4); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddHeader", _m_AddHeader); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddParameter", _m_AddParameter); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ForceAbort", _m_ForceAbort); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetId", _m_SetId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddTag", _m_AddTag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddCustomTimeout", _m_AddCustomTimeout); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Timeout", _m_Timeout); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ConnectTimeout", _m_ConnectTimeout); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "KeepAlive", _m_KeepAlive); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DisableCache", _m_DisableCache); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Send", _m_Send); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddToken", _m_AddToken); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddRevocableSession", _m_AddRevocableSession); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Request", _g_get_Request); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Id", _g_get_Id); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Tag", _g_get_Tag); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Type", _g_get_Type); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "CustomTimeout", _g_get_CustomTimeout); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Id", _s_set_Id); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Tag", _s_set_Tag); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Type", _s_set_Type); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "CustomTimeout", _s_set_CustomTimeout); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Create", _m_Create_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 Http.SingleHttp(); + 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 Http.SingleHttp constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Create_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + BestHTTP.HTTPMethods _type;translator.Get(L, 1, out _type); + string _url = LuaAPI.lua_tostring(L, 2); + System.Action _callback = translator.GetDelegate>(L, 3); + + var gen_ret = Http.SingleHttp.Create( _type, _url, _callback ); + 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_AddHeader(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Http.SingleHttp gen_to_be_invoked = (Http.SingleHttp)translator.FastGetCSObj(L, 1); + + + + { + string _key = LuaAPI.lua_tostring(L, 2); + string _value = LuaAPI.lua_tostring(L, 3); + + var gen_ret = gen_to_be_invoked.AddHeader( _key, _value ); + 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_AddParameter(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Http.SingleHttp gen_to_be_invoked = (Http.SingleHttp)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _body = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.AddParameter( _body ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& (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)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + string _key = LuaAPI.lua_tostring(L, 2); + string _value = LuaAPI.lua_tostring(L, 3); + bool _isLastOne = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.AddParameter( _key, _value, _isLastOne ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 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 = gen_to_be_invoked.AddParameter( _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 Http.SingleHttp.AddParameter!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ForceAbort(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Http.SingleHttp gen_to_be_invoked = (Http.SingleHttp)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ForceAbort( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Http.SingleHttp gen_to_be_invoked = (Http.SingleHttp)translator.FastGetCSObj(L, 1); + + + + { + string _id = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.SetId( _id ); + 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_AddTag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Http.SingleHttp gen_to_be_invoked = (Http.SingleHttp)translator.FastGetCSObj(L, 1); + + + + { + object _value = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.AddTag( _value ); + 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_AddCustomTimeout(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Http.SingleHttp gen_to_be_invoked = (Http.SingleHttp)translator.FastGetCSObj(L, 1); + + + + { + float _value = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.AddCustomTimeout( _value ); + 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_Timeout(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Http.SingleHttp gen_to_be_invoked = (Http.SingleHttp)translator.FastGetCSObj(L, 1); + + + + { + double _value = LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.Timeout( _value ); + 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_ConnectTimeout(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Http.SingleHttp gen_to_be_invoked = (Http.SingleHttp)translator.FastGetCSObj(L, 1); + + + + { + double _value = LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.ConnectTimeout( _value ); + 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_KeepAlive(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Http.SingleHttp gen_to_be_invoked = (Http.SingleHttp)translator.FastGetCSObj(L, 1); + + + + { + bool _value = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.KeepAlive( _value ); + 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_DisableCache(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Http.SingleHttp gen_to_be_invoked = (Http.SingleHttp)translator.FastGetCSObj(L, 1); + + + + { + bool _value = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.DisableCache( _value ); + 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_Send(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Http.SingleHttp gen_to_be_invoked = (Http.SingleHttp)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Send( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddToken(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Http.SingleHttp gen_to_be_invoked = (Http.SingleHttp)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.AddToken( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddRevocableSession(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Http.SingleHttp gen_to_be_invoked = (Http.SingleHttp)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.AddRevocableSession( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Request(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Http.SingleHttp gen_to_be_invoked = (Http.SingleHttp)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Request); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Id(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Http.SingleHttp gen_to_be_invoked = (Http.SingleHttp)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Id); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Tag(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Http.SingleHttp gen_to_be_invoked = (Http.SingleHttp)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.Tag); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Type(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Http.SingleHttp gen_to_be_invoked = (Http.SingleHttp)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Type); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_CustomTimeout(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Http.SingleHttp gen_to_be_invoked = (Http.SingleHttp)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.CustomTimeout); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Id(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Http.SingleHttp gen_to_be_invoked = (Http.SingleHttp)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Id = 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_Tag(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Http.SingleHttp gen_to_be_invoked = (Http.SingleHttp)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Tag = translator.GetObject(L, 2, typeof(object)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Type(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Http.SingleHttp gen_to_be_invoked = (Http.SingleHttp)translator.FastGetCSObj(L, 1); + BestHTTP.HTTPMethods gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.Type = 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_CustomTimeout(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Http.SingleHttp gen_to_be_invoked = (Http.SingleHttp)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.CustomTimeout = (float)LuaAPI.lua_tonumber(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/IAPManagerWrap.cs b/Assets/XLua/Gen/IAPManagerWrap.cs new file mode 100644 index 000000000..2999ac871 --- /dev/null +++ b/Assets/XLua/Gen/IAPManagerWrap.cs @@ -0,0 +1,718 @@ +#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 IAPManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IAPManager); + Utils.BeginObjectRegister(type, L, translator, 0, 16, 2, 2); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnInitialized", _m_OnInitialized); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnInitializeFailed", _m_OnInitializeFailed); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Buy", _m_Buy); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPurchaseFailed", _m_OnPurchaseFailed); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ProcessPurchase", _m_ProcessPurchase); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ConsumePurchase", _m_ConsumePurchase); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RestorePurchases", _m_RestorePurchases); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AnalysisSubscriptionProduct", _m_AnalysisSubscriptionProduct); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsInitialized", _m_IsInitialized); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetApplicationUsername", _m_SetApplicationUsername); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "MoneyStrSale", _m_MoneyStrSale); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "MoneySplit", _m_MoneySplit); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetLocalizedPrice", _m_GetLocalizedPrice); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetLocalizedIsoCurrencyCode", _m_GetLocalizedIsoCurrencyCode); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetLocalizedPriceAmount", _m_GetLocalizedPriceAmount); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "initCallback", _g_get_initCallback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "buyCallback", _g_get_buyCallback); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "initCallback", _s_set_initCallback); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "buyCallback", _s_set_buyCallback); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 2, 1); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetProductIdById", _m_GetProductIdById_xlua_st_); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "Instance", _g_get_Instance); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "instance", _g_get_instance); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "instance", _s_set_instance); + + + 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 IAPManager(); + 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 IAPManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IAPManager gen_to_be_invoked = (IAPManager)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.List _infos = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.Init( _infos ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnInitialized(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IAPManager gen_to_be_invoked = (IAPManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Purchasing.IStoreController _controller = (UnityEngine.Purchasing.IStoreController)translator.GetObject(L, 2, typeof(UnityEngine.Purchasing.IStoreController)); + UnityEngine.Purchasing.IExtensionProvider _extensions = (UnityEngine.Purchasing.IExtensionProvider)translator.GetObject(L, 3, typeof(UnityEngine.Purchasing.IExtensionProvider)); + + gen_to_be_invoked.OnInitialized( _controller, _extensions ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnInitializeFailed(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IAPManager gen_to_be_invoked = (IAPManager)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Purchasing.InitializationFailureReason _error;translator.Get(L, 2, out _error); + + gen_to_be_invoked.OnInitializeFailed( _error ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + UnityEngine.Purchasing.InitializationFailureReason _error;translator.Get(L, 2, out _error); + string _message = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.OnInitializeFailed( _error, _message ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to IAPManager.OnInitializeFailed!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Buy(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IAPManager gen_to_be_invoked = (IAPManager)translator.FastGetCSObj(L, 1); + + + + { + string _productId = LuaAPI.lua_tostring(L, 2); + string _payload = LuaAPI.lua_tostring(L, 3); + + var gen_ret = gen_to_be_invoked.Buy( _productId, _payload ); + 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_OnPurchaseFailed(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IAPManager gen_to_be_invoked = (IAPManager)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Purchasing.Product _pro = (UnityEngine.Purchasing.Product)translator.GetObject(L, 2, typeof(UnityEngine.Purchasing.Product)); + UnityEngine.Purchasing.PurchaseFailureReason _p;translator.Get(L, 3, out _p); + + gen_to_be_invoked.OnPurchaseFailed( _pro, _p ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Purchasing.Product _pro = (UnityEngine.Purchasing.Product)translator.GetObject(L, 2, typeof(UnityEngine.Purchasing.Product)); + UnityEngine.Purchasing.Extension.PurchaseFailureDescription _p = (UnityEngine.Purchasing.Extension.PurchaseFailureDescription)translator.GetObject(L, 3, typeof(UnityEngine.Purchasing.Extension.PurchaseFailureDescription)); + + gen_to_be_invoked.OnPurchaseFailed( _pro, _p ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to IAPManager.OnPurchaseFailed!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ProcessPurchase(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IAPManager gen_to_be_invoked = (IAPManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Purchasing.PurchaseEventArgs _e = (UnityEngine.Purchasing.PurchaseEventArgs)translator.GetObject(L, 2, typeof(UnityEngine.Purchasing.PurchaseEventArgs)); + + var gen_ret = gen_to_be_invoked.ProcessPurchase( _e ); + 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_ConsumePurchase(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IAPManager gen_to_be_invoked = (IAPManager)translator.FastGetCSObj(L, 1); + + + + { + string _productId = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.ConsumePurchase( _productId ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RestorePurchases(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IAPManager gen_to_be_invoked = (IAPManager)translator.FastGetCSObj(L, 1); + + + + { + System.Action _callBack = translator.GetDelegate(L, 2); + + gen_to_be_invoked.RestorePurchases( _callBack ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AnalysisSubscriptionProduct(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IAPManager gen_to_be_invoked = (IAPManager)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Purchasing.Product[] _products = (UnityEngine.Purchasing.Product[])translator.GetObject(L, 2, typeof(UnityEngine.Purchasing.Product[])); + + var gen_ret = gen_to_be_invoked.AnalysisSubscriptionProduct( _products ); + 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_IsInitialized(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IAPManager gen_to_be_invoked = (IAPManager)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsInitialized( ); + 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_GetProductIdById_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _id = LuaAPI.lua_tostring(L, 1); + + var gen_ret = IAPManager.GetProductIdById( _id ); + 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 _m_SetApplicationUsername(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IAPManager gen_to_be_invoked = (IAPManager)translator.FastGetCSObj(L, 1); + + + + { + string _applicationUsername = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SetApplicationUsername( _applicationUsername ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_MoneyStrSale(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IAPManager gen_to_be_invoked = (IAPManager)translator.FastGetCSObj(L, 1); + + + + { + string _str = LuaAPI.lua_tostring(L, 2); + float _sale = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.MoneyStrSale( _str, _sale ); + 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 _m_MoneySplit(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IAPManager gen_to_be_invoked = (IAPManager)translator.FastGetCSObj(L, 1); + + + + { + string _str = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.MoneySplit( _str ); + 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_GetLocalizedPrice(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IAPManager gen_to_be_invoked = (IAPManager)translator.FastGetCSObj(L, 1); + + + + { + string _productId = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetLocalizedPrice( _productId ); + 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 _m_GetLocalizedIsoCurrencyCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IAPManager gen_to_be_invoked = (IAPManager)translator.FastGetCSObj(L, 1); + + + + { + string _productId = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetLocalizedIsoCurrencyCode( _productId ); + 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 _m_GetLocalizedPriceAmount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IAPManager gen_to_be_invoked = (IAPManager)translator.FastGetCSObj(L, 1); + + + + { + string _productId = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetLocalizedPriceAmount( _productId ); + LuaAPI.lua_pushnumber(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_Instance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, IAPManager.Instance); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_initCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IAPManager gen_to_be_invoked = (IAPManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.initCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_buyCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IAPManager gen_to_be_invoked = (IAPManager)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.buyCallback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_instance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, IAPManager.instance); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_initCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IAPManager gen_to_be_invoked = (IAPManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.initCallback = translator.GetDelegate>(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_buyCallback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IAPManager gen_to_be_invoked = (IAPManager)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.buyCallback = translator.GetDelegate>(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_instance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + IAPManager.instance = (IAPManager)translator.GetObject(L, 1, typeof(IAPManager)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/IAPRequestWrap.cs b/Assets/XLua/Gen/IAPRequestWrap.cs new file mode 100644 index 000000000..66b317b3d --- /dev/null +++ b/Assets/XLua/Gen/IAPRequestWrap.cs @@ -0,0 +1,97 @@ +#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 IAPRequestWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IAPRequest); + 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, 1, 0); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "Instance", _g_get_Instance); + + + + 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 IAPRequest(); + 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 IAPRequest constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Instance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, IAPRequest.Instance); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/IUnityBannerWrap.cs b/Assets/XLua/Gen/IUnityBannerWrap.cs new file mode 100644 index 000000000..ef1143da5 --- /dev/null +++ b/Assets/XLua/Gen/IUnityBannerWrap.cs @@ -0,0 +1,277 @@ +#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 IUnityBannerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IUnityBanner); + Utils.BeginObjectRegister(type, L, translator, 0, 6, 0, 0); + + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBannerAdLoaded", _e_OnBannerAdLoaded); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBannerAdLeftApplication", _e_OnBannerAdLeftApplication); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBannerAdScreenDismissed", _e_OnBannerAdScreenDismissed); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBannerAdScreenPresented", _e_OnBannerAdScreenPresented); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBannerAdClicked", _e_OnBannerAdClicked); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBannerAdLoadFailed", _e_OnBannerAdLoadFailed); + + + + + 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, "IUnityBanner does not have a constructor!"); + } + + + + + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnBannerAdLoaded(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityBanner gen_to_be_invoked = (IUnityBanner)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnBannerAdLoaded += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnBannerAdLoaded -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityBanner.OnBannerAdLoaded!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnBannerAdLeftApplication(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityBanner gen_to_be_invoked = (IUnityBanner)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnBannerAdLeftApplication += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnBannerAdLeftApplication -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityBanner.OnBannerAdLeftApplication!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnBannerAdScreenDismissed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityBanner gen_to_be_invoked = (IUnityBanner)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnBannerAdScreenDismissed += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnBannerAdScreenDismissed -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityBanner.OnBannerAdScreenDismissed!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnBannerAdScreenPresented(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityBanner gen_to_be_invoked = (IUnityBanner)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnBannerAdScreenPresented += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnBannerAdScreenPresented -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityBanner.OnBannerAdScreenPresented!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnBannerAdClicked(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityBanner gen_to_be_invoked = (IUnityBanner)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnBannerAdClicked += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnBannerAdClicked -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityBanner.OnBannerAdClicked!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnBannerAdLoadFailed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityBanner gen_to_be_invoked = (IUnityBanner)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnBannerAdLoadFailed += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnBannerAdLoadFailed -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityBanner.OnBannerAdLoadFailed!"); + return 0; + } + + + + } +} diff --git a/Assets/XLua/Gen/IUnityImpressionDataWrap.cs b/Assets/XLua/Gen/IUnityImpressionDataWrap.cs new file mode 100644 index 000000000..66fcc3a4e --- /dev/null +++ b/Assets/XLua/Gen/IUnityImpressionDataWrap.cs @@ -0,0 +1,137 @@ +#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 IUnityImpressionDataWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IUnityImpressionData); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 0, 0); + + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnImpressionDataReady", _e_OnImpressionDataReady); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnImpressionSuccess", _e_OnImpressionSuccess); + + + + + 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, "IUnityImpressionData does not have a constructor!"); + } + + + + + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnImpressionDataReady(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityImpressionData gen_to_be_invoked = (IUnityImpressionData)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnImpressionDataReady += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnImpressionDataReady -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityImpressionData.OnImpressionDataReady!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnImpressionSuccess(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityImpressionData gen_to_be_invoked = (IUnityImpressionData)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnImpressionSuccess += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnImpressionSuccess -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityImpressionData.OnImpressionSuccess!"); + return 0; + } + + + + } +} diff --git a/Assets/XLua/Gen/IUnityInitializationWrap.cs b/Assets/XLua/Gen/IUnityInitializationWrap.cs new file mode 100644 index 000000000..072efb8e4 --- /dev/null +++ b/Assets/XLua/Gen/IUnityInitializationWrap.cs @@ -0,0 +1,102 @@ +#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 IUnityInitializationWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IUnityInitialization); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 0, 0); + + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnSdkInitializationCompletedEvent", _e_OnSdkInitializationCompletedEvent); + + + + + 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, "IUnityInitialization does not have a constructor!"); + } + + + + + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnSdkInitializationCompletedEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityInitialization gen_to_be_invoked = (IUnityInitialization)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnSdkInitializationCompletedEvent += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnSdkInitializationCompletedEvent -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityInitialization.OnSdkInitializationCompletedEvent!"); + return 0; + } + + + + } +} diff --git a/Assets/XLua/Gen/IUnityInterstitialWrap.cs b/Assets/XLua/Gen/IUnityInterstitialWrap.cs new file mode 100644 index 000000000..df683e6ed --- /dev/null +++ b/Assets/XLua/Gen/IUnityInterstitialWrap.cs @@ -0,0 +1,557 @@ +#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 IUnityInterstitialWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IUnityInterstitial); + Utils.BeginObjectRegister(type, L, translator, 0, 14, 0, 0); + + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnInterstitialAdShowFailed", _e_OnInterstitialAdShowFailed); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnInterstitialAdLoadFailed", _e_OnInterstitialAdLoadFailed); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnInterstitialAdReady", _e_OnInterstitialAdReady); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnInterstitialAdOpened", _e_OnInterstitialAdOpened); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnInterstitialAdClosed", _e_OnInterstitialAdClosed); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnInterstitialAdShowSucceeded", _e_OnInterstitialAdShowSucceeded); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnInterstitialAdClicked", _e_OnInterstitialAdClicked); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnInterstitialAdRewarded", _e_OnInterstitialAdRewarded); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnInterstitialAdReadyDemandOnly", _e_OnInterstitialAdReadyDemandOnly); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnInterstitialAdOpenedDemandOnly", _e_OnInterstitialAdOpenedDemandOnly); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnInterstitialAdClosedDemandOnly", _e_OnInterstitialAdClosedDemandOnly); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnInterstitialAdLoadFailedDemandOnly", _e_OnInterstitialAdLoadFailedDemandOnly); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnInterstitialAdClickedDemandOnly", _e_OnInterstitialAdClickedDemandOnly); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnInterstitialAdShowFailedDemandOnly", _e_OnInterstitialAdShowFailedDemandOnly); + + + + + 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, "IUnityInterstitial does not have a constructor!"); + } + + + + + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnInterstitialAdShowFailed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityInterstitial gen_to_be_invoked = (IUnityInterstitial)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnInterstitialAdShowFailed += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnInterstitialAdShowFailed -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityInterstitial.OnInterstitialAdShowFailed!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnInterstitialAdLoadFailed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityInterstitial gen_to_be_invoked = (IUnityInterstitial)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnInterstitialAdLoadFailed += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnInterstitialAdLoadFailed -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityInterstitial.OnInterstitialAdLoadFailed!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnInterstitialAdReady(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityInterstitial gen_to_be_invoked = (IUnityInterstitial)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnInterstitialAdReady += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnInterstitialAdReady -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityInterstitial.OnInterstitialAdReady!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnInterstitialAdOpened(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityInterstitial gen_to_be_invoked = (IUnityInterstitial)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnInterstitialAdOpened += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnInterstitialAdOpened -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityInterstitial.OnInterstitialAdOpened!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnInterstitialAdClosed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityInterstitial gen_to_be_invoked = (IUnityInterstitial)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnInterstitialAdClosed += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnInterstitialAdClosed -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityInterstitial.OnInterstitialAdClosed!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnInterstitialAdShowSucceeded(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityInterstitial gen_to_be_invoked = (IUnityInterstitial)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnInterstitialAdShowSucceeded += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnInterstitialAdShowSucceeded -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityInterstitial.OnInterstitialAdShowSucceeded!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnInterstitialAdClicked(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityInterstitial gen_to_be_invoked = (IUnityInterstitial)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnInterstitialAdClicked += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnInterstitialAdClicked -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityInterstitial.OnInterstitialAdClicked!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnInterstitialAdRewarded(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityInterstitial gen_to_be_invoked = (IUnityInterstitial)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnInterstitialAdRewarded += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnInterstitialAdRewarded -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityInterstitial.OnInterstitialAdRewarded!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnInterstitialAdReadyDemandOnly(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityInterstitial gen_to_be_invoked = (IUnityInterstitial)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnInterstitialAdReadyDemandOnly += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnInterstitialAdReadyDemandOnly -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityInterstitial.OnInterstitialAdReadyDemandOnly!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnInterstitialAdOpenedDemandOnly(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityInterstitial gen_to_be_invoked = (IUnityInterstitial)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnInterstitialAdOpenedDemandOnly += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnInterstitialAdOpenedDemandOnly -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityInterstitial.OnInterstitialAdOpenedDemandOnly!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnInterstitialAdClosedDemandOnly(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityInterstitial gen_to_be_invoked = (IUnityInterstitial)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnInterstitialAdClosedDemandOnly += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnInterstitialAdClosedDemandOnly -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityInterstitial.OnInterstitialAdClosedDemandOnly!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnInterstitialAdLoadFailedDemandOnly(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityInterstitial gen_to_be_invoked = (IUnityInterstitial)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnInterstitialAdLoadFailedDemandOnly += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnInterstitialAdLoadFailedDemandOnly -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityInterstitial.OnInterstitialAdLoadFailedDemandOnly!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnInterstitialAdClickedDemandOnly(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityInterstitial gen_to_be_invoked = (IUnityInterstitial)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnInterstitialAdClickedDemandOnly += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnInterstitialAdClickedDemandOnly -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityInterstitial.OnInterstitialAdClickedDemandOnly!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnInterstitialAdShowFailedDemandOnly(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityInterstitial gen_to_be_invoked = (IUnityInterstitial)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnInterstitialAdShowFailedDemandOnly += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnInterstitialAdShowFailedDemandOnly -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityInterstitial.OnInterstitialAdShowFailedDemandOnly!"); + return 0; + } + + + + } +} diff --git a/Assets/XLua/Gen/IUnityLevelPlayBannerWrap.cs b/Assets/XLua/Gen/IUnityLevelPlayBannerWrap.cs new file mode 100644 index 000000000..2d38bb5e6 --- /dev/null +++ b/Assets/XLua/Gen/IUnityLevelPlayBannerWrap.cs @@ -0,0 +1,277 @@ +#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 IUnityLevelPlayBannerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IUnityLevelPlayBanner); + Utils.BeginObjectRegister(type, L, translator, 0, 6, 0, 0); + + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnAdLoaded", _e_OnAdLoaded); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnAdLeftApplication", _e_OnAdLeftApplication); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnAdScreenDismissed", _e_OnAdScreenDismissed); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnAdScreenPresented", _e_OnAdScreenPresented); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnAdClicked", _e_OnAdClicked); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnAdLoadFailed", _e_OnAdLoadFailed); + + + + + 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, "IUnityLevelPlayBanner does not have a constructor!"); + } + + + + + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnAdLoaded(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityLevelPlayBanner gen_to_be_invoked = (IUnityLevelPlayBanner)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnAdLoaded += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnAdLoaded -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityLevelPlayBanner.OnAdLoaded!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnAdLeftApplication(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityLevelPlayBanner gen_to_be_invoked = (IUnityLevelPlayBanner)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnAdLeftApplication += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnAdLeftApplication -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityLevelPlayBanner.OnAdLeftApplication!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnAdScreenDismissed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityLevelPlayBanner gen_to_be_invoked = (IUnityLevelPlayBanner)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnAdScreenDismissed += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnAdScreenDismissed -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityLevelPlayBanner.OnAdScreenDismissed!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnAdScreenPresented(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityLevelPlayBanner gen_to_be_invoked = (IUnityLevelPlayBanner)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnAdScreenPresented += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnAdScreenPresented -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityLevelPlayBanner.OnAdScreenPresented!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnAdClicked(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityLevelPlayBanner gen_to_be_invoked = (IUnityLevelPlayBanner)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnAdClicked += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnAdClicked -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityLevelPlayBanner.OnAdClicked!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnAdLoadFailed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityLevelPlayBanner gen_to_be_invoked = (IUnityLevelPlayBanner)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnAdLoadFailed += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnAdLoadFailed -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityLevelPlayBanner.OnAdLoadFailed!"); + return 0; + } + + + + } +} diff --git a/Assets/XLua/Gen/IUnityLevelPlayInterstitialWrap.cs b/Assets/XLua/Gen/IUnityLevelPlayInterstitialWrap.cs new file mode 100644 index 000000000..3315c6854 --- /dev/null +++ b/Assets/XLua/Gen/IUnityLevelPlayInterstitialWrap.cs @@ -0,0 +1,312 @@ +#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 IUnityLevelPlayInterstitialWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IUnityLevelPlayInterstitial); + Utils.BeginObjectRegister(type, L, translator, 0, 7, 0, 0); + + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnAdShowFailed", _e_OnAdShowFailed); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnAdLoadFailed", _e_OnAdLoadFailed); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnAdReady", _e_OnAdReady); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnAdOpened", _e_OnAdOpened); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnAdClosed", _e_OnAdClosed); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnAdShowSucceeded", _e_OnAdShowSucceeded); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnAdClicked", _e_OnAdClicked); + + + + + 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, "IUnityLevelPlayInterstitial does not have a constructor!"); + } + + + + + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnAdShowFailed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityLevelPlayInterstitial gen_to_be_invoked = (IUnityLevelPlayInterstitial)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnAdShowFailed += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnAdShowFailed -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityLevelPlayInterstitial.OnAdShowFailed!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnAdLoadFailed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityLevelPlayInterstitial gen_to_be_invoked = (IUnityLevelPlayInterstitial)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnAdLoadFailed += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnAdLoadFailed -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityLevelPlayInterstitial.OnAdLoadFailed!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnAdReady(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityLevelPlayInterstitial gen_to_be_invoked = (IUnityLevelPlayInterstitial)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnAdReady += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnAdReady -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityLevelPlayInterstitial.OnAdReady!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnAdOpened(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityLevelPlayInterstitial gen_to_be_invoked = (IUnityLevelPlayInterstitial)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnAdOpened += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnAdOpened -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityLevelPlayInterstitial.OnAdOpened!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnAdClosed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityLevelPlayInterstitial gen_to_be_invoked = (IUnityLevelPlayInterstitial)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnAdClosed += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnAdClosed -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityLevelPlayInterstitial.OnAdClosed!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnAdShowSucceeded(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityLevelPlayInterstitial gen_to_be_invoked = (IUnityLevelPlayInterstitial)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnAdShowSucceeded += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnAdShowSucceeded -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityLevelPlayInterstitial.OnAdShowSucceeded!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnAdClicked(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityLevelPlayInterstitial gen_to_be_invoked = (IUnityLevelPlayInterstitial)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnAdClicked += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnAdClicked -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityLevelPlayInterstitial.OnAdClicked!"); + return 0; + } + + + + } +} diff --git a/Assets/XLua/Gen/IUnityLevelPlayRewardedVideoManualWrap.cs b/Assets/XLua/Gen/IUnityLevelPlayRewardedVideoManualWrap.cs new file mode 100644 index 000000000..335dc0cad --- /dev/null +++ b/Assets/XLua/Gen/IUnityLevelPlayRewardedVideoManualWrap.cs @@ -0,0 +1,137 @@ +#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 IUnityLevelPlayRewardedVideoManualWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IUnityLevelPlayRewardedVideoManual); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 0, 0); + + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnAdReady", _e_OnAdReady); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnAdLoadFailed", _e_OnAdLoadFailed); + + + + + 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, "IUnityLevelPlayRewardedVideoManual does not have a constructor!"); + } + + + + + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnAdReady(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityLevelPlayRewardedVideoManual gen_to_be_invoked = (IUnityLevelPlayRewardedVideoManual)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnAdReady += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnAdReady -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityLevelPlayRewardedVideoManual.OnAdReady!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnAdLoadFailed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityLevelPlayRewardedVideoManual gen_to_be_invoked = (IUnityLevelPlayRewardedVideoManual)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnAdLoadFailed += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnAdLoadFailed -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityLevelPlayRewardedVideoManual.OnAdLoadFailed!"); + return 0; + } + + + + } +} diff --git a/Assets/XLua/Gen/IUnityLevelPlayRewardedVideoWrap.cs b/Assets/XLua/Gen/IUnityLevelPlayRewardedVideoWrap.cs new file mode 100644 index 000000000..2f31b17bc --- /dev/null +++ b/Assets/XLua/Gen/IUnityLevelPlayRewardedVideoWrap.cs @@ -0,0 +1,312 @@ +#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 IUnityLevelPlayRewardedVideoWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IUnityLevelPlayRewardedVideo); + Utils.BeginObjectRegister(type, L, translator, 0, 7, 0, 0); + + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnAdShowFailed", _e_OnAdShowFailed); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnAdOpened", _e_OnAdOpened); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnAdClosed", _e_OnAdClosed); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnAdRewarded", _e_OnAdRewarded); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnAdClicked", _e_OnAdClicked); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnAdAvailable", _e_OnAdAvailable); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnAdUnavailable", _e_OnAdUnavailable); + + + + + 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, "IUnityLevelPlayRewardedVideo does not have a constructor!"); + } + + + + + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnAdShowFailed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityLevelPlayRewardedVideo gen_to_be_invoked = (IUnityLevelPlayRewardedVideo)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnAdShowFailed += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnAdShowFailed -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityLevelPlayRewardedVideo.OnAdShowFailed!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnAdOpened(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityLevelPlayRewardedVideo gen_to_be_invoked = (IUnityLevelPlayRewardedVideo)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnAdOpened += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnAdOpened -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityLevelPlayRewardedVideo.OnAdOpened!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnAdClosed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityLevelPlayRewardedVideo gen_to_be_invoked = (IUnityLevelPlayRewardedVideo)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnAdClosed += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnAdClosed -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityLevelPlayRewardedVideo.OnAdClosed!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnAdRewarded(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityLevelPlayRewardedVideo gen_to_be_invoked = (IUnityLevelPlayRewardedVideo)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnAdRewarded += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnAdRewarded -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityLevelPlayRewardedVideo.OnAdRewarded!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnAdClicked(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityLevelPlayRewardedVideo gen_to_be_invoked = (IUnityLevelPlayRewardedVideo)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnAdClicked += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnAdClicked -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityLevelPlayRewardedVideo.OnAdClicked!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnAdAvailable(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityLevelPlayRewardedVideo gen_to_be_invoked = (IUnityLevelPlayRewardedVideo)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnAdAvailable += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnAdAvailable -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityLevelPlayRewardedVideo.OnAdAvailable!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnAdUnavailable(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityLevelPlayRewardedVideo gen_to_be_invoked = (IUnityLevelPlayRewardedVideo)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnAdUnavailable += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnAdUnavailable -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityLevelPlayRewardedVideo.OnAdUnavailable!"); + return 0; + } + + + + } +} diff --git a/Assets/XLua/Gen/IUnityOfferwallWrap.cs b/Assets/XLua/Gen/IUnityOfferwallWrap.cs new file mode 100644 index 000000000..2dffefda6 --- /dev/null +++ b/Assets/XLua/Gen/IUnityOfferwallWrap.cs @@ -0,0 +1,277 @@ +#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 IUnityOfferwallWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IUnityOfferwall); + Utils.BeginObjectRegister(type, L, translator, 0, 6, 0, 0); + + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnOfferwallShowFailed", _e_OnOfferwallShowFailed); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnOfferwallOpened", _e_OnOfferwallOpened); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnOfferwallClosed", _e_OnOfferwallClosed); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnGetOfferwallCreditsFailed", _e_OnGetOfferwallCreditsFailed); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnOfferwallAdCredited", _e_OnOfferwallAdCredited); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnOfferwallAvailable", _e_OnOfferwallAvailable); + + + + + 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, "IUnityOfferwall does not have a constructor!"); + } + + + + + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnOfferwallShowFailed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityOfferwall gen_to_be_invoked = (IUnityOfferwall)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnOfferwallShowFailed += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnOfferwallShowFailed -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityOfferwall.OnOfferwallShowFailed!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnOfferwallOpened(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityOfferwall gen_to_be_invoked = (IUnityOfferwall)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnOfferwallOpened += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnOfferwallOpened -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityOfferwall.OnOfferwallOpened!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnOfferwallClosed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityOfferwall gen_to_be_invoked = (IUnityOfferwall)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnOfferwallClosed += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnOfferwallClosed -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityOfferwall.OnOfferwallClosed!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnGetOfferwallCreditsFailed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityOfferwall gen_to_be_invoked = (IUnityOfferwall)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnGetOfferwallCreditsFailed += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnGetOfferwallCreditsFailed -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityOfferwall.OnGetOfferwallCreditsFailed!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnOfferwallAdCredited(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityOfferwall gen_to_be_invoked = (IUnityOfferwall)translator.FastGetCSObj(L, 1); + System.Action> gen_delegate = translator.GetDelegate>>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action>!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnOfferwallAdCredited += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnOfferwallAdCredited -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityOfferwall.OnOfferwallAdCredited!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnOfferwallAvailable(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityOfferwall gen_to_be_invoked = (IUnityOfferwall)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnOfferwallAvailable += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnOfferwallAvailable -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityOfferwall.OnOfferwallAvailable!"); + return 0; + } + + + + } +} diff --git a/Assets/XLua/Gen/IUnityRewardedVideoManualWrap.cs b/Assets/XLua/Gen/IUnityRewardedVideoManualWrap.cs new file mode 100644 index 000000000..2f538a00f --- /dev/null +++ b/Assets/XLua/Gen/IUnityRewardedVideoManualWrap.cs @@ -0,0 +1,137 @@ +#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 IUnityRewardedVideoManualWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IUnityRewardedVideoManual); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 0, 0); + + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRewardedVideoAdReady", _e_OnRewardedVideoAdReady); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRewardedVideoAdLoadFailed", _e_OnRewardedVideoAdLoadFailed); + + + + + 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, "IUnityRewardedVideoManual does not have a constructor!"); + } + + + + + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnRewardedVideoAdReady(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityRewardedVideoManual gen_to_be_invoked = (IUnityRewardedVideoManual)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnRewardedVideoAdReady += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnRewardedVideoAdReady -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityRewardedVideoManual.OnRewardedVideoAdReady!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnRewardedVideoAdLoadFailed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityRewardedVideoManual gen_to_be_invoked = (IUnityRewardedVideoManual)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnRewardedVideoAdLoadFailed += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnRewardedVideoAdLoadFailed -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityRewardedVideoManual.OnRewardedVideoAdLoadFailed!"); + return 0; + } + + + + } +} diff --git a/Assets/XLua/Gen/IUnityRewardedVideoWrap.cs b/Assets/XLua/Gen/IUnityRewardedVideoWrap.cs new file mode 100644 index 000000000..dbc964fc6 --- /dev/null +++ b/Assets/XLua/Gen/IUnityRewardedVideoWrap.cs @@ -0,0 +1,592 @@ +#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 IUnityRewardedVideoWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IUnityRewardedVideo); + Utils.BeginObjectRegister(type, L, translator, 0, 15, 0, 0); + + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRewardedVideoAdShowFailed", _e_OnRewardedVideoAdShowFailed); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRewardedVideoAdOpened", _e_OnRewardedVideoAdOpened); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRewardedVideoAdClosed", _e_OnRewardedVideoAdClosed); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRewardedVideoAdStarted", _e_OnRewardedVideoAdStarted); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRewardedVideoAdEnded", _e_OnRewardedVideoAdEnded); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRewardedVideoAdRewarded", _e_OnRewardedVideoAdRewarded); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRewardedVideoAdClicked", _e_OnRewardedVideoAdClicked); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRewardedVideoAvailabilityChanged", _e_OnRewardedVideoAvailabilityChanged); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRewardedVideoAdOpenedDemandOnlyEvent", _e_OnRewardedVideoAdOpenedDemandOnlyEvent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRewardedVideoAdClosedDemandOnlyEvent", _e_OnRewardedVideoAdClosedDemandOnlyEvent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRewardedVideoAdLoadedDemandOnlyEvent", _e_OnRewardedVideoAdLoadedDemandOnlyEvent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRewardedVideoAdRewardedDemandOnlyEvent", _e_OnRewardedVideoAdRewardedDemandOnlyEvent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRewardedVideoAdShowFailedDemandOnlyEvent", _e_OnRewardedVideoAdShowFailedDemandOnlyEvent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRewardedVideoAdClickedDemandOnlyEvent", _e_OnRewardedVideoAdClickedDemandOnlyEvent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRewardedVideoAdLoadFailedDemandOnlyEvent", _e_OnRewardedVideoAdLoadFailedDemandOnlyEvent); + + + + + 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, "IUnityRewardedVideo does not have a constructor!"); + } + + + + + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnRewardedVideoAdShowFailed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityRewardedVideo gen_to_be_invoked = (IUnityRewardedVideo)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnRewardedVideoAdShowFailed += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnRewardedVideoAdShowFailed -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityRewardedVideo.OnRewardedVideoAdShowFailed!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnRewardedVideoAdOpened(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityRewardedVideo gen_to_be_invoked = (IUnityRewardedVideo)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnRewardedVideoAdOpened += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnRewardedVideoAdOpened -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityRewardedVideo.OnRewardedVideoAdOpened!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnRewardedVideoAdClosed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityRewardedVideo gen_to_be_invoked = (IUnityRewardedVideo)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnRewardedVideoAdClosed += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnRewardedVideoAdClosed -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityRewardedVideo.OnRewardedVideoAdClosed!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnRewardedVideoAdStarted(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityRewardedVideo gen_to_be_invoked = (IUnityRewardedVideo)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnRewardedVideoAdStarted += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnRewardedVideoAdStarted -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityRewardedVideo.OnRewardedVideoAdStarted!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnRewardedVideoAdEnded(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityRewardedVideo gen_to_be_invoked = (IUnityRewardedVideo)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnRewardedVideoAdEnded += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnRewardedVideoAdEnded -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityRewardedVideo.OnRewardedVideoAdEnded!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnRewardedVideoAdRewarded(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityRewardedVideo gen_to_be_invoked = (IUnityRewardedVideo)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnRewardedVideoAdRewarded += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnRewardedVideoAdRewarded -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityRewardedVideo.OnRewardedVideoAdRewarded!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnRewardedVideoAdClicked(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityRewardedVideo gen_to_be_invoked = (IUnityRewardedVideo)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnRewardedVideoAdClicked += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnRewardedVideoAdClicked -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityRewardedVideo.OnRewardedVideoAdClicked!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnRewardedVideoAvailabilityChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityRewardedVideo gen_to_be_invoked = (IUnityRewardedVideo)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnRewardedVideoAvailabilityChanged += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnRewardedVideoAvailabilityChanged -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityRewardedVideo.OnRewardedVideoAvailabilityChanged!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnRewardedVideoAdOpenedDemandOnlyEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityRewardedVideo gen_to_be_invoked = (IUnityRewardedVideo)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnRewardedVideoAdOpenedDemandOnlyEvent += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnRewardedVideoAdOpenedDemandOnlyEvent -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityRewardedVideo.OnRewardedVideoAdOpenedDemandOnlyEvent!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnRewardedVideoAdClosedDemandOnlyEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityRewardedVideo gen_to_be_invoked = (IUnityRewardedVideo)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnRewardedVideoAdClosedDemandOnlyEvent += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnRewardedVideoAdClosedDemandOnlyEvent -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityRewardedVideo.OnRewardedVideoAdClosedDemandOnlyEvent!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnRewardedVideoAdLoadedDemandOnlyEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityRewardedVideo gen_to_be_invoked = (IUnityRewardedVideo)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnRewardedVideoAdLoadedDemandOnlyEvent += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnRewardedVideoAdLoadedDemandOnlyEvent -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityRewardedVideo.OnRewardedVideoAdLoadedDemandOnlyEvent!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnRewardedVideoAdRewardedDemandOnlyEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityRewardedVideo gen_to_be_invoked = (IUnityRewardedVideo)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnRewardedVideoAdRewardedDemandOnlyEvent += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnRewardedVideoAdRewardedDemandOnlyEvent -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityRewardedVideo.OnRewardedVideoAdRewardedDemandOnlyEvent!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnRewardedVideoAdShowFailedDemandOnlyEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityRewardedVideo gen_to_be_invoked = (IUnityRewardedVideo)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnRewardedVideoAdShowFailedDemandOnlyEvent += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnRewardedVideoAdShowFailedDemandOnlyEvent -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityRewardedVideo.OnRewardedVideoAdShowFailedDemandOnlyEvent!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnRewardedVideoAdClickedDemandOnlyEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityRewardedVideo gen_to_be_invoked = (IUnityRewardedVideo)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnRewardedVideoAdClickedDemandOnlyEvent += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnRewardedVideoAdClickedDemandOnlyEvent -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityRewardedVideo.OnRewardedVideoAdClickedDemandOnlyEvent!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnRewardedVideoAdLoadFailedDemandOnlyEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnityRewardedVideo gen_to_be_invoked = (IUnityRewardedVideo)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnRewardedVideoAdLoadFailedDemandOnlyEvent += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnRewardedVideoAdLoadFailedDemandOnlyEvent -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnityRewardedVideo.OnRewardedVideoAdLoadFailedDemandOnlyEvent!"); + return 0; + } + + + + } +} diff --git a/Assets/XLua/Gen/IUnitySegmentWrap.cs b/Assets/XLua/Gen/IUnitySegmentWrap.cs new file mode 100644 index 000000000..368e2661d --- /dev/null +++ b/Assets/XLua/Gen/IUnitySegmentWrap.cs @@ -0,0 +1,102 @@ +#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 IUnitySegmentWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IUnitySegment); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 0, 0); + + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnSegmentRecieved", _e_OnSegmentRecieved); + + + + + 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, "IUnitySegment does not have a constructor!"); + } + + + + + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnSegmentRecieved(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IUnitySegment gen_to_be_invoked = (IUnitySegment)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnSegmentRecieved += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnSegmentRecieved -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IUnitySegment.OnSegmentRecieved!"); + return 0; + } + + + + } +} diff --git a/Assets/XLua/Gen/IronSourceAdInfoWrap.cs b/Assets/XLua/Gen/IronSourceAdInfoWrap.cs new file mode 100644 index 000000000..1434d79e3 --- /dev/null +++ b/Assets/XLua/Gen/IronSourceAdInfoWrap.cs @@ -0,0 +1,294 @@ +#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 IronSourceAdInfoWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IronSourceAdInfo); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 12, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "auctionId", _g_get_auctionId); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "adUnit", _g_get_adUnit); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "country", _g_get_country); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ab", _g_get_ab); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "segmentName", _g_get_segmentName); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "adNetwork", _g_get_adNetwork); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "instanceName", _g_get_instanceName); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "instanceId", _g_get_instanceId); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "revenue", _g_get_revenue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "precision", _g_get_precision); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lifetimeRevenue", _g_get_lifetimeRevenue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "encryptedCPM", _g_get_encryptedCPM); + + + + 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) == 2 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _json = LuaAPI.lua_tostring(L, 2); + + var gen_ret = new IronSourceAdInfo(_json); + 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 IronSourceAdInfo constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceAdInfo gen_to_be_invoked = (IronSourceAdInfo)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_auctionId(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceAdInfo gen_to_be_invoked = (IronSourceAdInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.auctionId); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_adUnit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceAdInfo gen_to_be_invoked = (IronSourceAdInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.adUnit); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_country(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceAdInfo gen_to_be_invoked = (IronSourceAdInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.country); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ab(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceAdInfo gen_to_be_invoked = (IronSourceAdInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.ab); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_segmentName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceAdInfo gen_to_be_invoked = (IronSourceAdInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.segmentName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_adNetwork(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceAdInfo gen_to_be_invoked = (IronSourceAdInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.adNetwork); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_instanceName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceAdInfo gen_to_be_invoked = (IronSourceAdInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.instanceName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_instanceId(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceAdInfo gen_to_be_invoked = (IronSourceAdInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.instanceId); + } 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); + + IronSourceAdInfo gen_to_be_invoked = (IronSourceAdInfo)translator.FastGetCSObj(L, 1); + translator.PushAny(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_precision(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceAdInfo gen_to_be_invoked = (IronSourceAdInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.precision); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lifetimeRevenue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceAdInfo gen_to_be_invoked = (IronSourceAdInfo)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.lifetimeRevenue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_encryptedCPM(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceAdInfo gen_to_be_invoked = (IronSourceAdInfo)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.encryptedCPM); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/IronSourceAdUnitsWrap.cs b/Assets/XLua/Gen/IronSourceAdUnitsWrap.cs new file mode 100644 index 000000000..eddaf4247 --- /dev/null +++ b/Assets/XLua/Gen/IronSourceAdUnitsWrap.cs @@ -0,0 +1,119 @@ +#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 IronSourceAdUnitsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IronSourceAdUnits); + 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, 4, 0); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "REWARDED_VIDEO", _g_get_REWARDED_VIDEO); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "INTERSTITIAL", _g_get_INTERSTITIAL); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "OFFERWALL", _g_get_OFFERWALL); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "BANNER", _g_get_BANNER); + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "IronSourceAdUnits does not have a constructor!"); + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_REWARDED_VIDEO(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, IronSourceAdUnits.REWARDED_VIDEO); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_INTERSTITIAL(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, IronSourceAdUnits.INTERSTITIAL); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_OFFERWALL(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, IronSourceAdUnits.OFFERWALL); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_BANNER(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, IronSourceAdUnits.BANNER); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/IronSourceBannerEventsWrap.cs b/Assets/XLua/Gen/IronSourceBannerEventsWrap.cs new file mode 100644 index 000000000..6cfcd73f3 --- /dev/null +++ b/Assets/XLua/Gen/IronSourceBannerEventsWrap.cs @@ -0,0 +1,264 @@ +#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 IronSourceBannerEventsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IronSourceBannerEvents); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 7, 0, 0); + + Utils.RegisterFunc(L, Utils.CLS_IDX, "onAdLoadedEvent", _e_onAdLoadedEvent); + Utils.RegisterFunc(L, Utils.CLS_IDX, "onAdLoadFailedEvent", _e_onAdLoadFailedEvent); + Utils.RegisterFunc(L, Utils.CLS_IDX, "onAdClickedEvent", _e_onAdClickedEvent); + Utils.RegisterFunc(L, Utils.CLS_IDX, "onAdScreenPresentedEvent", _e_onAdScreenPresentedEvent); + Utils.RegisterFunc(L, Utils.CLS_IDX, "onAdScreenDismissedEvent", _e_onAdScreenDismissedEvent); + Utils.RegisterFunc(L, Utils.CLS_IDX, "onAdLeftApplicationEvent", _e_onAdLeftApplicationEvent); + + + + + + 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 IronSourceBannerEvents(); + 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 IronSourceBannerEvents constructor!"); + + } + + + + + + + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onAdLoadedEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceBannerEvents.onAdLoadedEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceBannerEvents.onAdLoadedEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceBannerEvents.onAdLoadedEvent!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onAdLoadFailedEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceBannerEvents.onAdLoadFailedEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceBannerEvents.onAdLoadFailedEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceBannerEvents.onAdLoadFailedEvent!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onAdClickedEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceBannerEvents.onAdClickedEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceBannerEvents.onAdClickedEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceBannerEvents.onAdClickedEvent!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onAdScreenPresentedEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceBannerEvents.onAdScreenPresentedEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceBannerEvents.onAdScreenPresentedEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceBannerEvents.onAdScreenPresentedEvent!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onAdScreenDismissedEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceBannerEvents.onAdScreenDismissedEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceBannerEvents.onAdScreenDismissedEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceBannerEvents.onAdScreenDismissedEvent!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onAdLeftApplicationEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceBannerEvents.onAdLeftApplicationEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceBannerEvents.onAdLeftApplicationEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceBannerEvents.onAdLeftApplicationEvent!"); + } + + } +} diff --git a/Assets/XLua/Gen/IronSourceBannerSizeWrap.cs b/Assets/XLua/Gen/IronSourceBannerSizeWrap.cs new file mode 100644 index 000000000..56442e5de --- /dev/null +++ b/Assets/XLua/Gen/IronSourceBannerSizeWrap.cs @@ -0,0 +1,306 @@ +#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 IronSourceBannerSizeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IronSourceBannerSize); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 3, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAdaptive", _m_SetAdaptive); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsAdaptiveEnabled", _m_IsAdaptiveEnabled); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Description", _g_get_Description); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Width", _g_get_Width); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Height", _g_get_Height); + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 4, 4); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "BANNER", _g_get_BANNER); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "LARGE", _g_get_LARGE); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "RECTANGLE", _g_get_RECTANGLE); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "SMART", _g_get_SMART); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "BANNER", _s_set_BANNER); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "LARGE", _s_set_LARGE); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "RECTANGLE", _s_set_RECTANGLE); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "SMART", _s_set_SMART); + + + 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 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _width = LuaAPI.xlua_tointeger(L, 2); + int _height = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = new IronSourceBannerSize(_width, _height); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _description = LuaAPI.lua_tostring(L, 2); + + var gen_ret = new IronSourceBannerSize(_description); + 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 IronSourceBannerSize constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAdaptive(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceBannerSize gen_to_be_invoked = (IronSourceBannerSize)translator.FastGetCSObj(L, 1); + + + + { + bool _adaptive = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.SetAdaptive( _adaptive ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsAdaptiveEnabled(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceBannerSize gen_to_be_invoked = (IronSourceBannerSize)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsAdaptiveEnabled( ); + 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 _g_get_Description(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceBannerSize gen_to_be_invoked = (IronSourceBannerSize)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Description); + } 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); + + IronSourceBannerSize gen_to_be_invoked = (IronSourceBannerSize)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); + + IronSourceBannerSize gen_to_be_invoked = (IronSourceBannerSize)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 _g_get_BANNER(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, IronSourceBannerSize.BANNER); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_LARGE(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, IronSourceBannerSize.LARGE); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_RECTANGLE(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, IronSourceBannerSize.RECTANGLE); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_SMART(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, IronSourceBannerSize.SMART); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_BANNER(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + IronSourceBannerSize.BANNER = (IronSourceBannerSize)translator.GetObject(L, 1, typeof(IronSourceBannerSize)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_LARGE(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + IronSourceBannerSize.LARGE = (IronSourceBannerSize)translator.GetObject(L, 1, typeof(IronSourceBannerSize)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_RECTANGLE(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + IronSourceBannerSize.RECTANGLE = (IronSourceBannerSize)translator.GetObject(L, 1, typeof(IronSourceBannerSize)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_SMART(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + IronSourceBannerSize.SMART = (IronSourceBannerSize)translator.GetObject(L, 1, typeof(IronSourceBannerSize)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/IronSourceConfigWrap.cs b/Assets/XLua/Gen/IronSourceConfigWrap.cs new file mode 100644 index 000000000..6b195ef51 --- /dev/null +++ b/Assets/XLua/Gen/IronSourceConfigWrap.cs @@ -0,0 +1,213 @@ +#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 IronSourceConfigWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IronSourceConfig); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setLanguage", _m_setLanguage); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setClientSideCallbacks", _m_setClientSideCallbacks); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setRewardedVideoCustomParams", _m_setRewardedVideoCustomParams); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setOfferwallCustomParams", _m_setOfferwallCustomParams); + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 1, 0); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "Instance", _g_get_Instance); + + + + 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 IronSourceConfig(); + 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 IronSourceConfig constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setLanguage(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceConfig gen_to_be_invoked = (IronSourceConfig)translator.FastGetCSObj(L, 1); + + + + { + string _language = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.setLanguage( _language ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setClientSideCallbacks(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceConfig gen_to_be_invoked = (IronSourceConfig)translator.FastGetCSObj(L, 1); + + + + { + bool _status = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.setClientSideCallbacks( _status ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setRewardedVideoCustomParams(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceConfig gen_to_be_invoked = (IronSourceConfig)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.Dictionary _rewardedVideoCustomParams = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + + gen_to_be_invoked.setRewardedVideoCustomParams( _rewardedVideoCustomParams ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setOfferwallCustomParams(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceConfig gen_to_be_invoked = (IronSourceConfig)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.Dictionary _offerwallCustomParams = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + + gen_to_be_invoked.setOfferwallCustomParams( _offerwallCustomParams ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Instance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, IronSourceConfig.Instance); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/IronSourceConstantsWrap.cs b/Assets/XLua/Gen/IronSourceConstantsWrap.cs new file mode 100644 index 000000000..05de6aadc --- /dev/null +++ b/Assets/XLua/Gen/IronSourceConstantsWrap.cs @@ -0,0 +1,107 @@ +#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 IronSourceConstantsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IronSourceConstants); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 41, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GET_INSTANCE_KEY", IronSourceConstants.GET_INSTANCE_KEY); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ERROR_CODE", IronSourceConstants.ERROR_CODE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ERROR_DESCRIPTION", IronSourceConstants.ERROR_DESCRIPTION); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "INSTANCE_ID_KEY", IronSourceConstants.INSTANCE_ID_KEY); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PLACEMENT_KEY", IronSourceConstants.PLACEMENT_KEY); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EMPTY_STRING", IronSourceConstants.EMPTY_STRING); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "interstitialBridgeListenerClass", IronSourceConstants.interstitialBridgeListenerClass); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LevelPlayinterstitialBridgeListenerClass", IronSourceConstants.LevelPlayinterstitialBridgeListenerClass); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "rewardedVideoBridgeListenerClass", IronSourceConstants.rewardedVideoBridgeListenerClass); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "rewardedVideoManualBridgeListenerClass", IronSourceConstants.rewardedVideoManualBridgeListenerClass); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LevelPlayRewardedVideoBridgeListenerClass", IronSourceConstants.LevelPlayRewardedVideoBridgeListenerClass); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LevelPlayRewardedVideoManualBridgeListenerClass", IronSourceConstants.LevelPlayRewardedVideoManualBridgeListenerClass); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "bridgeClass", IronSourceConstants.bridgeClass); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "offerwallBridgeListenerClass", IronSourceConstants.offerwallBridgeListenerClass); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "bannerBridgeListenerClass", IronSourceConstants.bannerBridgeListenerClass); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LevelPlaybannerBridgeListenerClass", IronSourceConstants.LevelPlaybannerBridgeListenerClass); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "segmentBridgeListenerClass", IronSourceConstants.segmentBridgeListenerClass); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "impressionDataBridgeListenerClass", IronSourceConstants.impressionDataBridgeListenerClass); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "initializeBridgeListenerClass", IronSourceConstants.initializeBridgeListenerClass); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IMPRESSION_DATA_KEY_AUCTION_ID", IronSourceConstants.IMPRESSION_DATA_KEY_AUCTION_ID); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IMPRESSION_DATA_KEY_AD_UNIT", IronSourceConstants.IMPRESSION_DATA_KEY_AD_UNIT); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IMPRESSION_DATA_KEY_COUNTRY", IronSourceConstants.IMPRESSION_DATA_KEY_COUNTRY); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IMPRESSION_DATA_KEY_ABTEST", IronSourceConstants.IMPRESSION_DATA_KEY_ABTEST); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IMPRESSION_DATA_KEY_SEGMENT_NAME", IronSourceConstants.IMPRESSION_DATA_KEY_SEGMENT_NAME); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IMPRESSION_DATA_KEY_PLACEMENT", IronSourceConstants.IMPRESSION_DATA_KEY_PLACEMENT); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IMPRESSION_DATA_KEY_AD_NETWORK", IronSourceConstants.IMPRESSION_DATA_KEY_AD_NETWORK); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IMPRESSION_DATA_KEY_INSTANCE_NAME", IronSourceConstants.IMPRESSION_DATA_KEY_INSTANCE_NAME); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IMPRESSION_DATA_KEY_INSTANCE_ID", IronSourceConstants.IMPRESSION_DATA_KEY_INSTANCE_ID); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IMPRESSION_DATA_KEY_REVENUE", IronSourceConstants.IMPRESSION_DATA_KEY_REVENUE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IMPRESSION_DATA_KEY_PRECISION", IronSourceConstants.IMPRESSION_DATA_KEY_PRECISION); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IMPRESSION_DATA_KEY_LIFETIME_REVENUE", IronSourceConstants.IMPRESSION_DATA_KEY_LIFETIME_REVENUE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IMPRESSION_DATA_KEY_ENCRYPTED_CPM", IronSourceConstants.IMPRESSION_DATA_KEY_ENCRYPTED_CPM); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IMPRESSION_DATA_KEY_CONVERSION_VALUE", IronSourceConstants.IMPRESSION_DATA_KEY_CONVERSION_VALUE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GENDER_MALE", IronSourceConstants.GENDER_MALE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GENDER_FEMALE", IronSourceConstants.GENDER_FEMALE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GENDER_UNKNOWN", IronSourceConstants.GENDER_UNKNOWN); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IRONSOURCE_MEDIATION_SETTING_NAME", IronSourceConstants.IRONSOURCE_MEDIATION_SETTING_NAME); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IRONSOURCE_MEDIATED_NETWORK_SETTING_NAME", IronSourceConstants.IRONSOURCE_MEDIATED_NETWORK_SETTING_NAME); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IRONSOURCE_RESOURCES_PATH", IronSourceConstants.IRONSOURCE_RESOURCES_PATH); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IRONSOURCE_SKAN_ID_KEY", IronSourceConstants.IRONSOURCE_SKAN_ID_KEY); + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "IronSourceConstants does not have a constructor!"); + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/IronSourceDemoScriptWrap.cs b/Assets/XLua/Gen/IronSourceDemoScriptWrap.cs new file mode 100644 index 000000000..05d81a2c7 --- /dev/null +++ b/Assets/XLua/Gen/IronSourceDemoScriptWrap.cs @@ -0,0 +1,140 @@ +#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 IronSourceDemoScriptWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IronSourceDemoScript); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Start", _m_Start); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnGUI", _m_OnGUI); + + + + + + 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 IronSourceDemoScript(); + 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 IronSourceDemoScript constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Start(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceDemoScript gen_to_be_invoked = (IronSourceDemoScript)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Start( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnGUI(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceDemoScript gen_to_be_invoked = (IronSourceDemoScript)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.OnGUI( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/IronSourceErrorWrap.cs b/Assets/XLua/Gen/IronSourceErrorWrap.cs new file mode 100644 index 000000000..266c9db08 --- /dev/null +++ b/Assets/XLua/Gen/IronSourceErrorWrap.cs @@ -0,0 +1,202 @@ +#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 IronSourceErrorWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IronSourceError); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "getErrorCode", _m_getErrorCode); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "getDescription", _m_getDescription); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "getCode", _m_getCode); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + + + + + + 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 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + int _errorCode = LuaAPI.xlua_tointeger(L, 2); + string _errorDescription = LuaAPI.lua_tostring(L, 3); + + var gen_ret = new IronSourceError(_errorCode, _errorDescription); + 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 IronSourceError constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_getErrorCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceError gen_to_be_invoked = (IronSourceError)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.getErrorCode( ); + 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_getDescription(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceError gen_to_be_invoked = (IronSourceError)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.getDescription( ); + 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 _m_getCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceError gen_to_be_invoked = (IronSourceError)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.getCode( ); + 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_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceError gen_to_be_invoked = (IronSourceError)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); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/IronSourceEventsDispatcherWrap.cs b/Assets/XLua/Gen/IronSourceEventsDispatcherWrap.cs new file mode 100644 index 000000000..4735a6768 --- /dev/null +++ b/Assets/XLua/Gen/IronSourceEventsDispatcherWrap.cs @@ -0,0 +1,244 @@ +#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 IronSourceEventsDispatcherWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IronSourceEventsDispatcher); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "removeFromParent", _m_removeFromParent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Awake", _m_Awake); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnDisable", _m_OnDisable); + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 4, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "executeAction", _m_executeAction_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "initialize", _m_initialize_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "isCreated", _m_isCreated_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 IronSourceEventsDispatcher(); + 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 IronSourceEventsDispatcher constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_executeAction_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.Action _action = translator.GetDelegate(L, 1); + + IronSourceEventsDispatcher.executeAction( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_removeFromParent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceEventsDispatcher gen_to_be_invoked = (IronSourceEventsDispatcher)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.removeFromParent( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_initialize_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + IronSourceEventsDispatcher.initialize( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_isCreated_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = IronSourceEventsDispatcher.isCreated( ); + 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_Awake(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceEventsDispatcher gen_to_be_invoked = (IronSourceEventsDispatcher)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Awake( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnDisable(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceEventsDispatcher gen_to_be_invoked = (IronSourceEventsDispatcher)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.OnDisable( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/IronSourceEventsWrap.cs b/Assets/XLua/Gen/IronSourceEventsWrap.cs new file mode 100644 index 000000000..f1e393d3c --- /dev/null +++ b/Assets/XLua/Gen/IronSourceEventsWrap.cs @@ -0,0 +1,528 @@ +#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 IronSourceEventsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IronSourceEvents); + Utils.BeginObjectRegister(type, L, translator, 0, 6, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "onConsentViewDidFailToLoadWithError", _m_onConsentViewDidFailToLoadWithError); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "onConsentViewDidFailToShowWithError", _m_onConsentViewDidFailToShowWithError); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "onConsentViewDidAccept", _m_onConsentViewDidAccept); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "onConsentViewDidDismiss", _m_onConsentViewDidDismiss); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "onConsentViewDidLoadSuccess", _m_onConsentViewDidLoadSuccess); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "onConsentViewDidShowSuccess", _m_onConsentViewDidShowSuccess); + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 10, 0, 0); + + Utils.RegisterFunc(L, Utils.CLS_IDX, "onImpressionDataReadyEvent", _e_onImpressionDataReadyEvent); + Utils.RegisterFunc(L, Utils.CLS_IDX, "onSdkInitializationCompletedEvent", _e_onSdkInitializationCompletedEvent); + Utils.RegisterFunc(L, Utils.CLS_IDX, "onSegmentReceivedEvent", _e_onSegmentReceivedEvent); + Utils.RegisterFunc(L, Utils.CLS_IDX, "onConsentViewDidFailToLoadWithErrorEvent", _e_onConsentViewDidFailToLoadWithErrorEvent); + Utils.RegisterFunc(L, Utils.CLS_IDX, "onConsentViewDidFailToShowWithErrorEvent", _e_onConsentViewDidFailToShowWithErrorEvent); + Utils.RegisterFunc(L, Utils.CLS_IDX, "onConsentViewDidAcceptEvent", _e_onConsentViewDidAcceptEvent); + Utils.RegisterFunc(L, Utils.CLS_IDX, "onConsentViewDidDismissEvent", _e_onConsentViewDidDismissEvent); + Utils.RegisterFunc(L, Utils.CLS_IDX, "onConsentViewDidLoadSuccessEvent", _e_onConsentViewDidLoadSuccessEvent); + Utils.RegisterFunc(L, Utils.CLS_IDX, "onConsentViewDidShowSuccessEvent", _e_onConsentViewDidShowSuccessEvent); + + + + + + 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 IronSourceEvents(); + 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 IronSourceEvents constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_onConsentViewDidFailToLoadWithError(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceEvents gen_to_be_invoked = (IronSourceEvents)translator.FastGetCSObj(L, 1); + + + + { + string _args = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.onConsentViewDidFailToLoadWithError( _args ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_onConsentViewDidFailToShowWithError(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceEvents gen_to_be_invoked = (IronSourceEvents)translator.FastGetCSObj(L, 1); + + + + { + string _args = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.onConsentViewDidFailToShowWithError( _args ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_onConsentViewDidAccept(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceEvents gen_to_be_invoked = (IronSourceEvents)translator.FastGetCSObj(L, 1); + + + + { + string _consentViewType = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.onConsentViewDidAccept( _consentViewType ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_onConsentViewDidDismiss(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceEvents gen_to_be_invoked = (IronSourceEvents)translator.FastGetCSObj(L, 1); + + + + { + string _consentViewType = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.onConsentViewDidDismiss( _consentViewType ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_onConsentViewDidLoadSuccess(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceEvents gen_to_be_invoked = (IronSourceEvents)translator.FastGetCSObj(L, 1); + + + + { + string _consentViewType = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.onConsentViewDidLoadSuccess( _consentViewType ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_onConsentViewDidShowSuccess(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceEvents gen_to_be_invoked = (IronSourceEvents)translator.FastGetCSObj(L, 1); + + + + { + string _consentViewType = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.onConsentViewDidShowSuccess( _consentViewType ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onImpressionDataReadyEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceEvents.onImpressionDataReadyEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceEvents.onImpressionDataReadyEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceEvents.onImpressionDataReadyEvent!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onSdkInitializationCompletedEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceEvents.onSdkInitializationCompletedEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceEvents.onSdkInitializationCompletedEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceEvents.onSdkInitializationCompletedEvent!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onSegmentReceivedEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceEvents.onSegmentReceivedEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceEvents.onSegmentReceivedEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceEvents.onSegmentReceivedEvent!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onConsentViewDidFailToLoadWithErrorEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceEvents.onConsentViewDidFailToLoadWithErrorEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceEvents.onConsentViewDidFailToLoadWithErrorEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceEvents.onConsentViewDidFailToLoadWithErrorEvent!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onConsentViewDidFailToShowWithErrorEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceEvents.onConsentViewDidFailToShowWithErrorEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceEvents.onConsentViewDidFailToShowWithErrorEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceEvents.onConsentViewDidFailToShowWithErrorEvent!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onConsentViewDidAcceptEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceEvents.onConsentViewDidAcceptEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceEvents.onConsentViewDidAcceptEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceEvents.onConsentViewDidAcceptEvent!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onConsentViewDidDismissEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceEvents.onConsentViewDidDismissEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceEvents.onConsentViewDidDismissEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceEvents.onConsentViewDidDismissEvent!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onConsentViewDidLoadSuccessEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceEvents.onConsentViewDidLoadSuccessEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceEvents.onConsentViewDidLoadSuccessEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceEvents.onConsentViewDidLoadSuccessEvent!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onConsentViewDidShowSuccessEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceEvents.onConsentViewDidShowSuccessEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceEvents.onConsentViewDidShowSuccessEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceEvents.onConsentViewDidShowSuccessEvent!"); + } + + } +} diff --git a/Assets/XLua/Gen/IronSourceIAgentWrap.cs b/Assets/XLua/Gen/IronSourceIAgentWrap.cs new file mode 100644 index 000000000..b0fe49459 --- /dev/null +++ b/Assets/XLua/Gen/IronSourceIAgentWrap.cs @@ -0,0 +1,1490 @@ +#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 IronSourceIAgentWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IronSourceIAgent); + Utils.BeginObjectRegister(type, L, translator, 0, 46, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetWaterfallConfiguration", _m_SetWaterfallConfiguration); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "onApplicationPause", _m_onApplicationPause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "getAdvertiserId", _m_getAdvertiserId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "validateIntegration", _m_validateIntegration); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "shouldTrackNetworkState", _m_shouldTrackNetworkState); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setDynamicUserId", _m_setDynamicUserId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setAdaptersDebug", _m_setAdaptersDebug); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setMetaData", _m_setMetaData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "getConversionValue", _m_getConversionValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setManualLoadRewardedVideo", _m_setManualLoadRewardedVideo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setNetworkData", _m_setNetworkData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPauseGame", _m_SetPauseGame); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setUserId", _m_setUserId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "init", _m_init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "initISDemandOnly", _m_initISDemandOnly); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "loadRewardedVideo", _m_loadRewardedVideo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "showRewardedVideo", _m_showRewardedVideo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "isRewardedVideoAvailable", _m_isRewardedVideoAvailable); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "isRewardedVideoPlacementCapped", _m_isRewardedVideoPlacementCapped); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "getPlacementInfo", _m_getPlacementInfo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setRewardedVideoServerParams", _m_setRewardedVideoServerParams); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "clearRewardedVideoServerParams", _m_clearRewardedVideoServerParams); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "showISDemandOnlyRewardedVideo", _m_showISDemandOnlyRewardedVideo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "loadISDemandOnlyRewardedVideo", _m_loadISDemandOnlyRewardedVideo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "isISDemandOnlyRewardedVideoAvailable", _m_isISDemandOnlyRewardedVideoAvailable); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "loadInterstitial", _m_loadInterstitial); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "showInterstitial", _m_showInterstitial); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "isInterstitialReady", _m_isInterstitialReady); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "isInterstitialPlacementCapped", _m_isInterstitialPlacementCapped); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "loadISDemandOnlyInterstitial", _m_loadISDemandOnlyInterstitial); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "showISDemandOnlyInterstitial", _m_showISDemandOnlyInterstitial); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "isISDemandOnlyInterstitialReady", _m_isISDemandOnlyInterstitialReady); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "showOfferwall", _m_showOfferwall); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "isOfferwallAvailable", _m_isOfferwallAvailable); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "getOfferwallCredits", _m_getOfferwallCredits); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "loadBanner", _m_loadBanner); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "destroyBanner", _m_destroyBanner); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "displayBanner", _m_displayBanner); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "hideBanner", _m_hideBanner); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "isBannerPlacementCapped", _m_isBannerPlacementCapped); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setSegment", _m_setSegment); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setConsent", _m_setConsent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "loadConsentViewWithType", _m_loadConsentViewWithType); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "showConsentViewWithType", _m_showConsentViewWithType); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setAdRevenueData", _m_setAdRevenueData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "launchTestSuite", _m_launchTestSuite); + + + + + + 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, "IronSourceIAgent does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetWaterfallConfiguration(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + WaterfallConfiguration _waterfallConfiguration = (WaterfallConfiguration)translator.GetObject(L, 2, typeof(WaterfallConfiguration)); + AdFormat _adFormat;translator.Get(L, 3, out _adFormat); + + gen_to_be_invoked.SetWaterfallConfiguration( _waterfallConfiguration, _adFormat ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_onApplicationPause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + bool _pause = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.onApplicationPause( _pause ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_getAdvertiserId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.getAdvertiserId( ); + 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 _m_validateIntegration(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.validateIntegration( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_shouldTrackNetworkState(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + bool _track = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.shouldTrackNetworkState( _track ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setDynamicUserId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + string _dynamicUserId = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.setDynamicUserId( _dynamicUserId ); + 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_setAdaptersDebug(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + bool _enabled = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.setAdaptersDebug( _enabled ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setMetaData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 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); + + gen_to_be_invoked.setMetaData( _key, _value ); + + + + return 0; + } + if(gen_param_count >= 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 3) || (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING))) + { + string _key = LuaAPI.lua_tostring(L, 2); + string[] _values = translator.GetParams(L, 3); + + gen_to_be_invoked.setMetaData( _key, _values ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceIAgent.setMetaData!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_getConversionValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.getConversionValue( ); + 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_setManualLoadRewardedVideo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + bool _isOn = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.setManualLoadRewardedVideo( _isOn ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setNetworkData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + string _networkKey = LuaAPI.lua_tostring(L, 2); + string _networkData = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.setNetworkData( _networkKey, _networkData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetPauseGame(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + bool _pause = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.SetPauseGame( _pause ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setUserId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + string _userId = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.setUserId( _userId ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _appKey = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.init( _appKey ); + + + + return 0; + } + if(gen_param_count >= 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 3) || (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING))) + { + string _appKey = LuaAPI.lua_tostring(L, 2); + string[] _adUnits = translator.GetParams(L, 3); + + gen_to_be_invoked.init( _appKey, _adUnits ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceIAgent.init!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_initISDemandOnly(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + string _appKey = LuaAPI.lua_tostring(L, 2); + string[] _adUnits = translator.GetParams(L, 3); + + gen_to_be_invoked.initISDemandOnly( _appKey, _adUnits ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_loadRewardedVideo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.loadRewardedVideo( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_showRewardedVideo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.showRewardedVideo( ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _placementName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.showRewardedVideo( _placementName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceIAgent.showRewardedVideo!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_isRewardedVideoAvailable(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.isRewardedVideoAvailable( ); + 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_isRewardedVideoPlacementCapped(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + string _placementName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.isRewardedVideoPlacementCapped( _placementName ); + 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_getPlacementInfo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.getPlacementInfo( _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_setRewardedVideoServerParams(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.Dictionary _parameters = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + + gen_to_be_invoked.setRewardedVideoServerParams( _parameters ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_clearRewardedVideoServerParams(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.clearRewardedVideoServerParams( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_showISDemandOnlyRewardedVideo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + string _instanceId = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.showISDemandOnlyRewardedVideo( _instanceId ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_loadISDemandOnlyRewardedVideo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + string _instanceId = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.loadISDemandOnlyRewardedVideo( _instanceId ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_isISDemandOnlyRewardedVideoAvailable(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + string _instanceId = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.isISDemandOnlyRewardedVideoAvailable( _instanceId ); + 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_loadInterstitial(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.loadInterstitial( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_showInterstitial(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.showInterstitial( ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _placementName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.showInterstitial( _placementName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceIAgent.showInterstitial!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_isInterstitialReady(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.isInterstitialReady( ); + 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_isInterstitialPlacementCapped(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + string _placementName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.isInterstitialPlacementCapped( _placementName ); + 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_loadISDemandOnlyInterstitial(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + string _instanceId = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.loadISDemandOnlyInterstitial( _instanceId ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_showISDemandOnlyInterstitial(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + string _instanceId = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.showISDemandOnlyInterstitial( _instanceId ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_isISDemandOnlyInterstitialReady(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + string _instanceId = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.isISDemandOnlyInterstitialReady( _instanceId ); + 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_showOfferwall(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.showOfferwall( ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _placementName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.showOfferwall( _placementName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceIAgent.showOfferwall!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_isOfferwallAvailable(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.isOfferwallAvailable( ); + 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_getOfferwallCredits(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.getOfferwallCredits( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_loadBanner(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + IronSourceBannerSize _size = (IronSourceBannerSize)translator.GetObject(L, 2, typeof(IronSourceBannerSize)); + IronSourceBannerPosition _position;translator.Get(L, 3, out _position); + + gen_to_be_invoked.loadBanner( _size, _position ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)) + { + IronSourceBannerSize _size = (IronSourceBannerSize)translator.GetObject(L, 2, typeof(IronSourceBannerSize)); + IronSourceBannerPosition _position;translator.Get(L, 3, out _position); + string _placementName = LuaAPI.lua_tostring(L, 4); + + gen_to_be_invoked.loadBanner( _size, _position, _placementName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceIAgent.loadBanner!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_destroyBanner(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.destroyBanner( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_displayBanner(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.displayBanner( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_hideBanner(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.hideBanner( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_isBannerPlacementCapped(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + string _placementName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.isBannerPlacementCapped( _placementName ); + 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_setSegment(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + IronSourceSegment _segment = (IronSourceSegment)translator.GetObject(L, 2, typeof(IronSourceSegment)); + + gen_to_be_invoked.setSegment( _segment ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setConsent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + bool _consent = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.setConsent( _consent ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_loadConsentViewWithType(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + string _consentViewType = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.loadConsentViewWithType( _consentViewType ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_showConsentViewWithType(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + string _consentViewType = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.showConsentViewWithType( _consentViewType ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setAdRevenueData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + string _dataSource = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.Dictionary _impressionData = (System.Collections.Generic.Dictionary)translator.GetObject(L, 3, typeof(System.Collections.Generic.Dictionary)); + + gen_to_be_invoked.setAdRevenueData( _dataSource, _impressionData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_launchTestSuite(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceIAgent gen_to_be_invoked = (IronSourceIAgent)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.launchTestSuite( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/IronSourceImpressionDataWrap.cs b/Assets/XLua/Gen/IronSourceImpressionDataWrap.cs new file mode 100644 index 000000000..6e268061d --- /dev/null +++ b/Assets/XLua/Gen/IronSourceImpressionDataWrap.cs @@ -0,0 +1,339 @@ +#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 IronSourceImpressionDataWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IronSourceImpressionData); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 15, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "auctionId", _g_get_auctionId); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "adUnit", _g_get_adUnit); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "country", _g_get_country); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ab", _g_get_ab); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "segmentName", _g_get_segmentName); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "placement", _g_get_placement); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "adNetwork", _g_get_adNetwork); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "instanceName", _g_get_instanceName); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "instanceId", _g_get_instanceId); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "revenue", _g_get_revenue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "precision", _g_get_precision); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lifetimeRevenue", _g_get_lifetimeRevenue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "encryptedCPM", _g_get_encryptedCPM); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "conversionValue", _g_get_conversionValue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "allData", _g_get_allData); + + + + 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) == 2 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _json = LuaAPI.lua_tostring(L, 2); + + var gen_ret = new IronSourceImpressionData(_json); + 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 IronSourceImpressionData constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceImpressionData gen_to_be_invoked = (IronSourceImpressionData)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_auctionId(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceImpressionData gen_to_be_invoked = (IronSourceImpressionData)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.auctionId); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_adUnit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceImpressionData gen_to_be_invoked = (IronSourceImpressionData)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.adUnit); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_country(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceImpressionData gen_to_be_invoked = (IronSourceImpressionData)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.country); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ab(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceImpressionData gen_to_be_invoked = (IronSourceImpressionData)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.ab); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_segmentName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceImpressionData gen_to_be_invoked = (IronSourceImpressionData)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.segmentName); + } 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); + + IronSourceImpressionData gen_to_be_invoked = (IronSourceImpressionData)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 _g_get_adNetwork(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceImpressionData gen_to_be_invoked = (IronSourceImpressionData)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.adNetwork); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_instanceName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceImpressionData gen_to_be_invoked = (IronSourceImpressionData)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.instanceName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_instanceId(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceImpressionData gen_to_be_invoked = (IronSourceImpressionData)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.instanceId); + } 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); + + IronSourceImpressionData gen_to_be_invoked = (IronSourceImpressionData)translator.FastGetCSObj(L, 1); + translator.PushAny(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_precision(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceImpressionData gen_to_be_invoked = (IronSourceImpressionData)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.precision); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lifetimeRevenue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceImpressionData gen_to_be_invoked = (IronSourceImpressionData)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.lifetimeRevenue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_encryptedCPM(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceImpressionData gen_to_be_invoked = (IronSourceImpressionData)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.encryptedCPM); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_conversionValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceImpressionData gen_to_be_invoked = (IronSourceImpressionData)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.conversionValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_allData(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceImpressionData gen_to_be_invoked = (IronSourceImpressionData)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.allData); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/IronSourceInitilizerWrap.cs b/Assets/XLua/Gen/IronSourceInitilizerWrap.cs new file mode 100644 index 000000000..2ca8846bc --- /dev/null +++ b/Assets/XLua/Gen/IronSourceInitilizerWrap.cs @@ -0,0 +1,84 @@ +#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 IronSourceInitilizerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IronSourceInitilizer); + 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) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new IronSourceInitilizer(); + 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 IronSourceInitilizer constructor!"); + + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/IronSourceInterstitialEventsWrap.cs b/Assets/XLua/Gen/IronSourceInterstitialEventsWrap.cs new file mode 100644 index 000000000..de449c58f --- /dev/null +++ b/Assets/XLua/Gen/IronSourceInterstitialEventsWrap.cs @@ -0,0 +1,294 @@ +#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 IronSourceInterstitialEventsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IronSourceInterstitialEvents); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 8, 0, 0); + + Utils.RegisterFunc(L, Utils.CLS_IDX, "onAdReadyEvent", _e_onAdReadyEvent); + Utils.RegisterFunc(L, Utils.CLS_IDX, "onAdLoadFailedEvent", _e_onAdLoadFailedEvent); + Utils.RegisterFunc(L, Utils.CLS_IDX, "onAdOpenedEvent", _e_onAdOpenedEvent); + Utils.RegisterFunc(L, Utils.CLS_IDX, "onAdClosedEvent", _e_onAdClosedEvent); + Utils.RegisterFunc(L, Utils.CLS_IDX, "onAdShowSucceededEvent", _e_onAdShowSucceededEvent); + Utils.RegisterFunc(L, Utils.CLS_IDX, "onAdShowFailedEvent", _e_onAdShowFailedEvent); + Utils.RegisterFunc(L, Utils.CLS_IDX, "onAdClickedEvent", _e_onAdClickedEvent); + + + + + + 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 IronSourceInterstitialEvents(); + 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 IronSourceInterstitialEvents constructor!"); + + } + + + + + + + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onAdReadyEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceInterstitialEvents.onAdReadyEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceInterstitialEvents.onAdReadyEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceInterstitialEvents.onAdReadyEvent!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onAdLoadFailedEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceInterstitialEvents.onAdLoadFailedEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceInterstitialEvents.onAdLoadFailedEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceInterstitialEvents.onAdLoadFailedEvent!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onAdOpenedEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceInterstitialEvents.onAdOpenedEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceInterstitialEvents.onAdOpenedEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceInterstitialEvents.onAdOpenedEvent!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onAdClosedEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceInterstitialEvents.onAdClosedEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceInterstitialEvents.onAdClosedEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceInterstitialEvents.onAdClosedEvent!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onAdShowSucceededEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceInterstitialEvents.onAdShowSucceededEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceInterstitialEvents.onAdShowSucceededEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceInterstitialEvents.onAdShowSucceededEvent!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onAdShowFailedEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceInterstitialEvents.onAdShowFailedEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceInterstitialEvents.onAdShowFailedEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceInterstitialEvents.onAdShowFailedEvent!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onAdClickedEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceInterstitialEvents.onAdClickedEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceInterstitialEvents.onAdClickedEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceInterstitialEvents.onAdClickedEvent!"); + } + + } +} diff --git a/Assets/XLua/Gen/IronSourceJSON_JsonWrap.cs b/Assets/XLua/Gen/IronSourceJSON_JsonWrap.cs new file mode 100644 index 000000000..952158adb --- /dev/null +++ b/Assets/XLua/Gen/IronSourceJSON_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 IronSourceJSONJsonWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IronSourceJSON.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, "IronSourceJSON.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 = IronSourceJSON.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 = IronSourceJSON.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/IronSourceMediationSettingsWrap.cs b/Assets/XLua/Gen/IronSourceMediationSettingsWrap.cs new file mode 100644 index 000000000..db9dd3742 --- /dev/null +++ b/Assets/XLua/Gen/IronSourceMediationSettingsWrap.cs @@ -0,0 +1,302 @@ +#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 IronSourceMediationSettingsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IronSourceMediationSettings); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 7, 7); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AndroidAppKey", _g_get_AndroidAppKey); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IOSAppKey", _g_get_IOSAppKey); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "EnableIronsourceSDKInitAPI", _g_get_EnableIronsourceSDKInitAPI); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AddIronsourceSkadnetworkID", _g_get_AddIronsourceSkadnetworkID); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "DeclareAD_IDPermission", _g_get_DeclareAD_IDPermission); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "EnableAdapterDebug", _g_get_EnableAdapterDebug); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "EnableIntegrationHelper", _g_get_EnableIntegrationHelper); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "AndroidAppKey", _s_set_AndroidAppKey); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "IOSAppKey", _s_set_IOSAppKey); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "EnableIronsourceSDKInitAPI", _s_set_EnableIronsourceSDKInitAPI); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "AddIronsourceSkadnetworkID", _s_set_AddIronsourceSkadnetworkID); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "DeclareAD_IDPermission", _s_set_DeclareAD_IDPermission); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "EnableAdapterDebug", _s_set_EnableAdapterDebug); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "EnableIntegrationHelper", _s_set_EnableIntegrationHelper); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IRONSOURCE_SETTINGS_ASSET_PATH", IronSourceMediationSettings.IRONSOURCE_SETTINGS_ASSET_PATH); + + + + + 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 IronSourceMediationSettings(); + 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 IronSourceMediationSettings constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AndroidAppKey(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceMediationSettings gen_to_be_invoked = (IronSourceMediationSettings)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.AndroidAppKey); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IOSAppKey(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceMediationSettings gen_to_be_invoked = (IronSourceMediationSettings)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.IOSAppKey); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_EnableIronsourceSDKInitAPI(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceMediationSettings gen_to_be_invoked = (IronSourceMediationSettings)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.EnableIronsourceSDKInitAPI); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AddIronsourceSkadnetworkID(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceMediationSettings gen_to_be_invoked = (IronSourceMediationSettings)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.AddIronsourceSkadnetworkID); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DeclareAD_IDPermission(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceMediationSettings gen_to_be_invoked = (IronSourceMediationSettings)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.DeclareAD_IDPermission); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_EnableAdapterDebug(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceMediationSettings gen_to_be_invoked = (IronSourceMediationSettings)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.EnableAdapterDebug); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_EnableIntegrationHelper(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceMediationSettings gen_to_be_invoked = (IronSourceMediationSettings)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.EnableIntegrationHelper); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_AndroidAppKey(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceMediationSettings gen_to_be_invoked = (IronSourceMediationSettings)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.AndroidAppKey = 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_IOSAppKey(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceMediationSettings gen_to_be_invoked = (IronSourceMediationSettings)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.IOSAppKey = 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_EnableIronsourceSDKInitAPI(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceMediationSettings gen_to_be_invoked = (IronSourceMediationSettings)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.EnableIronsourceSDKInitAPI = 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_AddIronsourceSkadnetworkID(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceMediationSettings gen_to_be_invoked = (IronSourceMediationSettings)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.AddIronsourceSkadnetworkID = 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_DeclareAD_IDPermission(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceMediationSettings gen_to_be_invoked = (IronSourceMediationSettings)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.DeclareAD_IDPermission = 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_EnableAdapterDebug(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceMediationSettings gen_to_be_invoked = (IronSourceMediationSettings)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.EnableAdapterDebug = 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_EnableIntegrationHelper(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceMediationSettings gen_to_be_invoked = (IronSourceMediationSettings)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.EnableIntegrationHelper = LuaAPI.lua_toboolean(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/IronSourcePlacementWrap.cs b/Assets/XLua/Gen/IronSourcePlacementWrap.cs new file mode 100644 index 000000000..474d95d92 --- /dev/null +++ b/Assets/XLua/Gen/IronSourcePlacementWrap.cs @@ -0,0 +1,203 @@ +#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 IronSourcePlacementWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IronSourcePlacement); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "getRewardName", _m_getRewardName); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "getRewardAmount", _m_getRewardAmount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "getPlacementName", _m_getPlacementName); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + + + + + + 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) == 4 && (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) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + string _placementName = LuaAPI.lua_tostring(L, 2); + string _rewardName = LuaAPI.lua_tostring(L, 3); + int _rewardAmount = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = new IronSourcePlacement(_placementName, _rewardName, _rewardAmount); + 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 IronSourcePlacement constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_getRewardName(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourcePlacement gen_to_be_invoked = (IronSourcePlacement)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.getRewardName( ); + 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 _m_getRewardAmount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourcePlacement gen_to_be_invoked = (IronSourcePlacement)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.getRewardAmount( ); + 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_getPlacementName(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourcePlacement gen_to_be_invoked = (IronSourcePlacement)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.getPlacementName( ); + 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 _m_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourcePlacement gen_to_be_invoked = (IronSourcePlacement)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); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/IronSourceRewardedVideoEventsWrap.cs b/Assets/XLua/Gen/IronSourceRewardedVideoEventsWrap.cs new file mode 100644 index 000000000..bb51b0342 --- /dev/null +++ b/Assets/XLua/Gen/IronSourceRewardedVideoEventsWrap.cs @@ -0,0 +1,354 @@ +#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 IronSourceRewardedVideoEventsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IronSourceRewardedVideoEvents); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 10, 0, 0); + + Utils.RegisterFunc(L, Utils.CLS_IDX, "onAdShowFailedEvent", _e_onAdShowFailedEvent); + Utils.RegisterFunc(L, Utils.CLS_IDX, "onAdOpenedEvent", _e_onAdOpenedEvent); + Utils.RegisterFunc(L, Utils.CLS_IDX, "onAdClosedEvent", _e_onAdClosedEvent); + Utils.RegisterFunc(L, Utils.CLS_IDX, "onAdRewardedEvent", _e_onAdRewardedEvent); + Utils.RegisterFunc(L, Utils.CLS_IDX, "onAdClickedEvent", _e_onAdClickedEvent); + Utils.RegisterFunc(L, Utils.CLS_IDX, "onAdAvailableEvent", _e_onAdAvailableEvent); + Utils.RegisterFunc(L, Utils.CLS_IDX, "onAdUnavailableEvent", _e_onAdUnavailableEvent); + Utils.RegisterFunc(L, Utils.CLS_IDX, "onAdLoadFailedEvent", _e_onAdLoadFailedEvent); + Utils.RegisterFunc(L, Utils.CLS_IDX, "onAdReadyEvent", _e_onAdReadyEvent); + + + + + + 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 IronSourceRewardedVideoEvents(); + 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 IronSourceRewardedVideoEvents constructor!"); + + } + + + + + + + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onAdShowFailedEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceRewardedVideoEvents.onAdShowFailedEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceRewardedVideoEvents.onAdShowFailedEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceRewardedVideoEvents.onAdShowFailedEvent!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onAdOpenedEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceRewardedVideoEvents.onAdOpenedEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceRewardedVideoEvents.onAdOpenedEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceRewardedVideoEvents.onAdOpenedEvent!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onAdClosedEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceRewardedVideoEvents.onAdClosedEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceRewardedVideoEvents.onAdClosedEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceRewardedVideoEvents.onAdClosedEvent!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onAdRewardedEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceRewardedVideoEvents.onAdRewardedEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceRewardedVideoEvents.onAdRewardedEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceRewardedVideoEvents.onAdRewardedEvent!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onAdClickedEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceRewardedVideoEvents.onAdClickedEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceRewardedVideoEvents.onAdClickedEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceRewardedVideoEvents.onAdClickedEvent!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onAdAvailableEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceRewardedVideoEvents.onAdAvailableEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceRewardedVideoEvents.onAdAvailableEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceRewardedVideoEvents.onAdAvailableEvent!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onAdUnavailableEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceRewardedVideoEvents.onAdUnavailableEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceRewardedVideoEvents.onAdUnavailableEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceRewardedVideoEvents.onAdUnavailableEvent!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onAdLoadFailedEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceRewardedVideoEvents.onAdLoadFailedEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceRewardedVideoEvents.onAdLoadFailedEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceRewardedVideoEvents.onAdLoadFailedEvent!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onAdReadyEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + IronSourceRewardedVideoEvents.onAdReadyEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + IronSourceRewardedVideoEvents.onAdReadyEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to IronSourceRewardedVideoEvents.onAdReadyEvent!"); + } + + } +} diff --git a/Assets/XLua/Gen/IronSourceSegmentAndroidWrap.cs b/Assets/XLua/Gen/IronSourceSegmentAndroidWrap.cs new file mode 100644 index 000000000..843a9fca7 --- /dev/null +++ b/Assets/XLua/Gen/IronSourceSegmentAndroidWrap.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 IronSourceSegmentAndroidWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IronSourceSegmentAndroid); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "onSegmentRecieved", _m_onSegmentRecieved); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnSegmentRecieved", _e_OnSegmentRecieved); + + + + + 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 IronSourceSegmentAndroid(); + 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 IronSourceSegmentAndroid constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_onSegmentRecieved(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceSegmentAndroid gen_to_be_invoked = (IronSourceSegmentAndroid)translator.FastGetCSObj(L, 1); + + + + { + string _segmentName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.onSegmentRecieved( _segmentName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnSegmentRecieved(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + IronSourceSegmentAndroid gen_to_be_invoked = (IronSourceSegmentAndroid)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnSegmentRecieved += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnSegmentRecieved -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to IronSourceSegmentAndroid.OnSegmentRecieved!"); + return 0; + } + + + + } +} diff --git a/Assets/XLua/Gen/IronSourceSegmentWrap.cs b/Assets/XLua/Gen/IronSourceSegmentWrap.cs new file mode 100644 index 000000000..11e369ee2 --- /dev/null +++ b/Assets/XLua/Gen/IronSourceSegmentWrap.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 IronSourceSegmentWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IronSourceSegment); + 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, "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, "userCreationDate", _g_get_userCreationDate); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "iapt", _g_get_iapt); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "segmentName", _g_get_segmentName); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "customs", _g_get_customs); + + 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, "userCreationDate", _s_set_userCreationDate); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "iapt", _s_set_iapt); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "segmentName", _s_set_segmentName); + 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 IronSourceSegment(); + 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 IronSourceSegment constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setCustom(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSourceSegment gen_to_be_invoked = (IronSourceSegment)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); + + + IronSourceSegment gen_to_be_invoked = (IronSourceSegment)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_age(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceSegment gen_to_be_invoked = (IronSourceSegment)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); + + IronSourceSegment gen_to_be_invoked = (IronSourceSegment)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); + + IronSourceSegment gen_to_be_invoked = (IronSourceSegment)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); + + IronSourceSegment gen_to_be_invoked = (IronSourceSegment)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_userCreationDate(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceSegment gen_to_be_invoked = (IronSourceSegment)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_iapt(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceSegment gen_to_be_invoked = (IronSourceSegment)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.iapt); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_segmentName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceSegment gen_to_be_invoked = (IronSourceSegment)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.segmentName); + } 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); + + IronSourceSegment gen_to_be_invoked = (IronSourceSegment)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_age(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceSegment gen_to_be_invoked = (IronSourceSegment)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); + + IronSourceSegment gen_to_be_invoked = (IronSourceSegment)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); + + IronSourceSegment gen_to_be_invoked = (IronSourceSegment)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); + + IronSourceSegment gen_to_be_invoked = (IronSourceSegment)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_userCreationDate(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceSegment gen_to_be_invoked = (IronSourceSegment)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_iapt(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceSegment gen_to_be_invoked = (IronSourceSegment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.iapt = 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_segmentName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceSegment gen_to_be_invoked = (IronSourceSegment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.segmentName = 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_customs(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + IronSourceSegment gen_to_be_invoked = (IronSourceSegment)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/IronSourceUtilsWrap.cs b/Assets/XLua/Gen/IronSourceUtilsWrap.cs new file mode 100644 index 000000000..599857e71 --- /dev/null +++ b/Assets/XLua/Gen/IronSourceUtilsWrap.cs @@ -0,0 +1,140 @@ +#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 IronSourceUtilsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IronSourceUtils); + 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, "getErrorFromErrorObject", _m_getErrorFromErrorObject_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "getPlacementFromObject", _m_getPlacementFromObject_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 IronSourceUtils(); + 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 IronSourceUtils constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_getErrorFromErrorObject_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + object _descriptionObject = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = IronSourceUtils.getErrorFromErrorObject( _descriptionObject ); + 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_getPlacementFromObject_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + object _placementObject = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = IronSourceUtils.getPlacementFromObject( _placementObject ); + 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/IronSourceWrap.cs b/Assets/XLua/Gen/IronSourceWrap.cs new file mode 100644 index 000000000..7ed9015be --- /dev/null +++ b/Assets/XLua/Gen/IronSourceWrap.cs @@ -0,0 +1,1299 @@ +#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 IronSourceWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(IronSource); + Utils.BeginObjectRegister(type, L, translator, 0, 36, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetWaterfallConfiguration", _m_SetWaterfallConfiguration); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "onApplicationPause", _m_onApplicationPause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "getAdvertiserId", _m_getAdvertiserId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "validateIntegration", _m_validateIntegration); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "shouldTrackNetworkState", _m_shouldTrackNetworkState); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setDynamicUserId", _m_setDynamicUserId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setAdaptersDebug", _m_setAdaptersDebug); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setMetaData", _m_setMetaData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "getConversionValue", _m_getConversionValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setManualLoadRewardedVideo", _m_setManualLoadRewardedVideo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setNetworkData", _m_setNetworkData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPauseGame", _m_SetPauseGame); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setUserId", _m_setUserId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "init", _m_init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "loadRewardedVideo", _m_loadRewardedVideo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "showRewardedVideo", _m_showRewardedVideo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "getPlacementInfo", _m_getPlacementInfo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "isRewardedVideoAvailable", _m_isRewardedVideoAvailable); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "isRewardedVideoPlacementCapped", _m_isRewardedVideoPlacementCapped); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setRewardedVideoServerParams", _m_setRewardedVideoServerParams); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "clearRewardedVideoServerParams", _m_clearRewardedVideoServerParams); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "loadInterstitial", _m_loadInterstitial); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "showInterstitial", _m_showInterstitial); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "isInterstitialReady", _m_isInterstitialReady); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "isInterstitialPlacementCapped", _m_isInterstitialPlacementCapped); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "loadBanner", _m_loadBanner); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "destroyBanner", _m_destroyBanner); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "displayBanner", _m_displayBanner); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "hideBanner", _m_hideBanner); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "isBannerPlacementCapped", _m_isBannerPlacementCapped); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setSegment", _m_setSegment); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setConsent", _m_setConsent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "loadConsentViewWithType", _m_loadConsentViewWithType); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "showConsentViewWithType", _m_showConsentViewWithType); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setAdRevenueData", _m_setAdRevenueData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "launchTestSuite", _m_launchTestSuite); + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 4, 2, 1); + Utils.RegisterFunc(L, Utils.CLS_IDX, "pluginVersion", _m_pluginVersion_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "unityVersion", _m_unityVersion_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "setUnsupportedPlatform", _m_setUnsupportedPlatform_xlua_st_); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "Agent", _g_get_Agent); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "UNITY_PLUGIN_VERSION", _g_get_UNITY_PLUGIN_VERSION); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "UNITY_PLUGIN_VERSION", _s_set_UNITY_PLUGIN_VERSION); + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "IronSource does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_pluginVersion_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = IronSource.pluginVersion( ); + 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 _m_unityVersion_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = IronSource.unityVersion( ); + 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 _m_setUnsupportedPlatform_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + IronSource.setUnsupportedPlatform( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetWaterfallConfiguration(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + WaterfallConfiguration _waterfallConfiguration = (WaterfallConfiguration)translator.GetObject(L, 2, typeof(WaterfallConfiguration)); + AdFormat _adFormat;translator.Get(L, 3, out _adFormat); + + gen_to_be_invoked.SetWaterfallConfiguration( _waterfallConfiguration, _adFormat ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_onApplicationPause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + bool _pause = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.onApplicationPause( _pause ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_getAdvertiserId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.getAdvertiserId( ); + 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 _m_validateIntegration(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.validateIntegration( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_shouldTrackNetworkState(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + bool _track = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.shouldTrackNetworkState( _track ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setDynamicUserId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + string _dynamicUserId = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.setDynamicUserId( _dynamicUserId ); + 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_setAdaptersDebug(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + bool _enabled = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.setAdaptersDebug( _enabled ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setMetaData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 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); + + gen_to_be_invoked.setMetaData( _key, _value ); + + + + return 0; + } + if(gen_param_count >= 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 3) || (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING))) + { + string _key = LuaAPI.lua_tostring(L, 2); + string[] _values = translator.GetParams(L, 3); + + gen_to_be_invoked.setMetaData( _key, _values ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to IronSource.setMetaData!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_getConversionValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.getConversionValue( ); + 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_setManualLoadRewardedVideo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + bool _isOn = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.setManualLoadRewardedVideo( _isOn ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setNetworkData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + string _networkKey = LuaAPI.lua_tostring(L, 2); + string _networkData = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.setNetworkData( _networkKey, _networkData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetPauseGame(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + bool _pause = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.SetPauseGame( _pause ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setUserId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + string _userId = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.setUserId( _userId ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _appKey = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.init( _appKey ); + + + + return 0; + } + if(gen_param_count >= 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 3) || (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING))) + { + string _appKey = LuaAPI.lua_tostring(L, 2); + string[] _adUnits = translator.GetParams(L, 3); + + gen_to_be_invoked.init( _appKey, _adUnits ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to IronSource.init!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_loadRewardedVideo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.loadRewardedVideo( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_showRewardedVideo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.showRewardedVideo( ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _placementName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.showRewardedVideo( _placementName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to IronSource.showRewardedVideo!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_getPlacementInfo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + string _placementName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.getPlacementInfo( _placementName ); + 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_isRewardedVideoAvailable(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.isRewardedVideoAvailable( ); + 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_isRewardedVideoPlacementCapped(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + string _placementName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.isRewardedVideoPlacementCapped( _placementName ); + 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_setRewardedVideoServerParams(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.Dictionary _parameters = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + + gen_to_be_invoked.setRewardedVideoServerParams( _parameters ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_clearRewardedVideoServerParams(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.clearRewardedVideoServerParams( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_loadInterstitial(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.loadInterstitial( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_showInterstitial(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.showInterstitial( ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _placementName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.showInterstitial( _placementName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to IronSource.showInterstitial!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_isInterstitialReady(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.isInterstitialReady( ); + 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_isInterstitialPlacementCapped(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + string _placementName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.isInterstitialPlacementCapped( _placementName ); + 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_loadBanner(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + IronSourceBannerSize _size = (IronSourceBannerSize)translator.GetObject(L, 2, typeof(IronSourceBannerSize)); + IronSourceBannerPosition _position;translator.Get(L, 3, out _position); + + gen_to_be_invoked.loadBanner( _size, _position ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)) + { + IronSourceBannerSize _size = (IronSourceBannerSize)translator.GetObject(L, 2, typeof(IronSourceBannerSize)); + IronSourceBannerPosition _position;translator.Get(L, 3, out _position); + string _placementName = LuaAPI.lua_tostring(L, 4); + + gen_to_be_invoked.loadBanner( _size, _position, _placementName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to IronSource.loadBanner!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_destroyBanner(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.destroyBanner( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_displayBanner(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.displayBanner( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_hideBanner(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.hideBanner( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_isBannerPlacementCapped(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + string _placementName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.isBannerPlacementCapped( _placementName ); + 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_setSegment(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + IronSourceSegment _segment = (IronSourceSegment)translator.GetObject(L, 2, typeof(IronSourceSegment)); + + gen_to_be_invoked.setSegment( _segment ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setConsent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + bool _consent = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.setConsent( _consent ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_loadConsentViewWithType(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + string _consentViewType = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.loadConsentViewWithType( _consentViewType ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_showConsentViewWithType(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + string _consentViewType = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.showConsentViewWithType( _consentViewType ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setAdRevenueData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + string _dataSource = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.Dictionary _impressionData = (System.Collections.Generic.Dictionary)translator.GetObject(L, 3, typeof(System.Collections.Generic.Dictionary)); + + gen_to_be_invoked.setAdRevenueData( _dataSource, _impressionData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_launchTestSuite(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + IronSource gen_to_be_invoked = (IronSource)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.launchTestSuite( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Agent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, IronSource.Agent); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UNITY_PLUGIN_VERSION(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, IronSource.UNITY_PLUGIN_VERSION); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_UNITY_PLUGIN_VERSION(RealStatePtr L) + { + try { + + IronSource.UNITY_PLUGIN_VERSION = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/LuaAssetWrap.cs b/Assets/XLua/Gen/LuaAssetWrap.cs new file mode 100644 index 000000000..2d3f5b113 --- /dev/null +++ b/Assets/XLua/Gen/LuaAssetWrap.cs @@ -0,0 +1,297 @@ +#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 LuaAssetWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(LuaAsset); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 2, 2); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetDecodeBytes", _m_GetDecodeBytes); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "encode", _g_get_encode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "data", _g_get_data); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "encode", _s_set_encode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "data", _s_set_data); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 2, 2); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Require", _m_Require_xlua_st_); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "LuaDecodeKey", _g_get_LuaDecodeKey); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "LuaSearchingPaths", _g_get_LuaSearchingPaths); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "LuaDecodeKey", _s_set_LuaDecodeKey); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "LuaSearchingPaths", _s_set_LuaSearchingPaths); + + + 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 LuaAsset(); + 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 LuaAsset constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetDecodeBytes(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + LuaAsset gen_to_be_invoked = (LuaAsset)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetDecodeBytes( ); + 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 _m_Require_xlua_st_(RealStatePtr L) + { + try { + + + + 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 _luapath = LuaAPI.lua_tostring(L, 1); + + var gen_ret = LuaAsset.Require( ref _luapath ); + LuaAPI.lua_pushstring(L, gen_ret); + LuaAPI.lua_pushstring(L, _luapath); + + + + + return 2; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + string _luapath = LuaAPI.lua_tostring(L, 1); + string _search = LuaAPI.lua_tostring(L, 2); + int _retry = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = LuaAsset.Require( _luapath, _search, _retry ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _luapath = LuaAPI.lua_tostring(L, 1); + string _search = LuaAPI.lua_tostring(L, 2); + + var gen_ret = LuaAsset.Require( _luapath, _search ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _luapath = LuaAPI.lua_tostring(L, 1); + + var gen_ret = LuaAsset.Require( _luapath ); + LuaAPI.lua_pushstring(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 LuaAsset.Require!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_LuaDecodeKey(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, LuaAsset.LuaDecodeKey); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_LuaSearchingPaths(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, LuaAsset.LuaSearchingPaths); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_encode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + LuaAsset gen_to_be_invoked = (LuaAsset)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.encode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_data(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + LuaAsset gen_to_be_invoked = (LuaAsset)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.data); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_LuaDecodeKey(RealStatePtr L) + { + try { + + LuaAsset.LuaDecodeKey = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_LuaSearchingPaths(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + LuaAsset.LuaSearchingPaths = (string[])translator.GetObject(L, 1, typeof(string[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_encode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + LuaAsset gen_to_be_invoked = (LuaAsset)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.encode = 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_data(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + LuaAsset gen_to_be_invoked = (LuaAsset)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.data = LuaAPI.lua_tobytes(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/MonkeyPostWrap.cs b/Assets/XLua/Gen/MonkeyPostWrap.cs new file mode 100644 index 000000000..aed3e044c --- /dev/null +++ b/Assets/XLua/Gen/MonkeyPostWrap.cs @@ -0,0 +1,361 @@ +#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 MonkeyPostWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(MonkeyPost); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 8, 8); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "_material", _g_get__material); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "_threshold", _g_get__threshold); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "_intensity", _g_get__intensity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "_soft", _g_get__soft); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "_brightness", _g_get__brightness); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "_contrast", _g_get__contrast); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "_saturation", _g_get__saturation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "_gamma", _g_get__gamma); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "_material", _s_set__material); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "_threshold", _s_set__threshold); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "_intensity", _s_set__intensity); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "_soft", _s_set__soft); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "_brightness", _s_set__brightness); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "_contrast", _s_set__contrast); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "_saturation", _s_set__saturation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "_gamma", _s_set__gamma); + + + 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 MonkeyPost(); + 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 MonkeyPost constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + MonkeyPost gen_to_be_invoked = (MonkeyPost)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Init( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get__material(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + MonkeyPost gen_to_be_invoked = (MonkeyPost)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked._material); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get__threshold(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + MonkeyPost gen_to_be_invoked = (MonkeyPost)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked._threshold); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get__intensity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + MonkeyPost gen_to_be_invoked = (MonkeyPost)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked._intensity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get__soft(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + MonkeyPost gen_to_be_invoked = (MonkeyPost)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked._soft); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get__brightness(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + MonkeyPost gen_to_be_invoked = (MonkeyPost)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked._brightness); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get__contrast(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + MonkeyPost gen_to_be_invoked = (MonkeyPost)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked._contrast); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get__saturation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + MonkeyPost gen_to_be_invoked = (MonkeyPost)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked._saturation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get__gamma(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + MonkeyPost gen_to_be_invoked = (MonkeyPost)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineColor(L, gen_to_be_invoked._gamma); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set__material(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + MonkeyPost gen_to_be_invoked = (MonkeyPost)translator.FastGetCSObj(L, 1); + gen_to_be_invoked._material = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set__threshold(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + MonkeyPost gen_to_be_invoked = (MonkeyPost)translator.FastGetCSObj(L, 1); + gen_to_be_invoked._threshold = (float)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__intensity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + MonkeyPost gen_to_be_invoked = (MonkeyPost)translator.FastGetCSObj(L, 1); + gen_to_be_invoked._intensity = (float)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__soft(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + MonkeyPost gen_to_be_invoked = (MonkeyPost)translator.FastGetCSObj(L, 1); + gen_to_be_invoked._soft = (float)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__brightness(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + MonkeyPost gen_to_be_invoked = (MonkeyPost)translator.FastGetCSObj(L, 1); + gen_to_be_invoked._brightness = (float)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__contrast(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + MonkeyPost gen_to_be_invoked = (MonkeyPost)translator.FastGetCSObj(L, 1); + gen_to_be_invoked._contrast = (float)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__saturation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + MonkeyPost gen_to_be_invoked = (MonkeyPost)translator.FastGetCSObj(L, 1); + gen_to_be_invoked._saturation = (float)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__gamma(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + MonkeyPost gen_to_be_invoked = (MonkeyPost)translator.FastGetCSObj(L, 1); + UnityEngine.Color gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked._gamma = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/PackUnpack.cs b/Assets/XLua/Gen/PackUnpack.cs new file mode 100644 index 000000000..432782a33 --- /dev/null +++ b/Assets/XLua/Gen/PackUnpack.cs @@ -0,0 +1,542 @@ +#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 System; + + +namespace XLua +{ + public static partial class CopyByValue + { + + + public static void UnPack(ObjectTranslator translator, RealStatePtr L, int idx, out UnityEngine.Vector2 val) + { + val = new UnityEngine.Vector2(); + int top = LuaAPI.lua_gettop(L); + + if (Utils.LoadField(L, idx, "x")) + { + + translator.Get(L, top + 1, out val.x); + + } + LuaAPI.lua_pop(L, 1); + + if (Utils.LoadField(L, idx, "y")) + { + + translator.Get(L, top + 1, out val.y); + + } + LuaAPI.lua_pop(L, 1); + + } + + public static bool Pack(IntPtr buff, int offset, UnityEngine.Vector2 field) + { + + if(!LuaAPI.xlua_pack_float2(buff, offset, field.x, field.y)) + { + return false; + } + + return true; + } + public static bool UnPack(IntPtr buff, int offset, out UnityEngine.Vector2 field) + { + field = default(UnityEngine.Vector2); + + float x = default(float); + float y = default(float); + + if(!LuaAPI.xlua_unpack_float2(buff, offset, out x, out y)) + { + return false; + } + field.x = x; + field.y = y; + + + return true; + } + + + public static void UnPack(ObjectTranslator translator, RealStatePtr L, int idx, out UnityEngine.Vector3 val) + { + val = new UnityEngine.Vector3(); + int top = LuaAPI.lua_gettop(L); + + if (Utils.LoadField(L, idx, "x")) + { + + translator.Get(L, top + 1, out val.x); + + } + LuaAPI.lua_pop(L, 1); + + if (Utils.LoadField(L, idx, "y")) + { + + translator.Get(L, top + 1, out val.y); + + } + LuaAPI.lua_pop(L, 1); + + if (Utils.LoadField(L, idx, "z")) + { + + translator.Get(L, top + 1, out val.z); + + } + LuaAPI.lua_pop(L, 1); + + } + + public static bool Pack(IntPtr buff, int offset, UnityEngine.Vector3 field) + { + + if(!LuaAPI.xlua_pack_float3(buff, offset, field.x, field.y, field.z)) + { + return false; + } + + return true; + } + public static bool UnPack(IntPtr buff, int offset, out UnityEngine.Vector3 field) + { + field = default(UnityEngine.Vector3); + + float x = default(float); + float y = default(float); + float z = default(float); + + if(!LuaAPI.xlua_unpack_float3(buff, offset, out x, out y, out z)) + { + return false; + } + field.x = x; + field.y = y; + field.z = z; + + + return true; + } + + + public static void UnPack(ObjectTranslator translator, RealStatePtr L, int idx, out UnityEngine.Vector4 val) + { + val = new UnityEngine.Vector4(); + int top = LuaAPI.lua_gettop(L); + + if (Utils.LoadField(L, idx, "x")) + { + + translator.Get(L, top + 1, out val.x); + + } + LuaAPI.lua_pop(L, 1); + + if (Utils.LoadField(L, idx, "y")) + { + + translator.Get(L, top + 1, out val.y); + + } + LuaAPI.lua_pop(L, 1); + + if (Utils.LoadField(L, idx, "z")) + { + + translator.Get(L, top + 1, out val.z); + + } + LuaAPI.lua_pop(L, 1); + + if (Utils.LoadField(L, idx, "w")) + { + + translator.Get(L, top + 1, out val.w); + + } + LuaAPI.lua_pop(L, 1); + + } + + public static bool Pack(IntPtr buff, int offset, UnityEngine.Vector4 field) + { + + if(!LuaAPI.xlua_pack_float4(buff, offset, field.x, field.y, field.z, field.w)) + { + return false; + } + + return true; + } + public static bool UnPack(IntPtr buff, int offset, out UnityEngine.Vector4 field) + { + field = default(UnityEngine.Vector4); + + float x = default(float); + float y = default(float); + float z = default(float); + float w = default(float); + + if(!LuaAPI.xlua_unpack_float4(buff, offset, out x, out y, out z, out w)) + { + return false; + } + field.x = x; + field.y = y; + field.z = z; + field.w = w; + + + return true; + } + + + public static void UnPack(ObjectTranslator translator, RealStatePtr L, int idx, out UnityEngine.Color val) + { + val = new UnityEngine.Color(); + int top = LuaAPI.lua_gettop(L); + + if (Utils.LoadField(L, idx, "r")) + { + + translator.Get(L, top + 1, out val.r); + + } + LuaAPI.lua_pop(L, 1); + + if (Utils.LoadField(L, idx, "g")) + { + + translator.Get(L, top + 1, out val.g); + + } + LuaAPI.lua_pop(L, 1); + + if (Utils.LoadField(L, idx, "b")) + { + + translator.Get(L, top + 1, out val.b); + + } + LuaAPI.lua_pop(L, 1); + + if (Utils.LoadField(L, idx, "a")) + { + + translator.Get(L, top + 1, out val.a); + + } + LuaAPI.lua_pop(L, 1); + + } + + public static bool Pack(IntPtr buff, int offset, UnityEngine.Color field) + { + + if(!LuaAPI.xlua_pack_float4(buff, offset, field.r, field.g, field.b, field.a)) + { + return false; + } + + return true; + } + public static bool UnPack(IntPtr buff, int offset, out UnityEngine.Color field) + { + field = default(UnityEngine.Color); + + float r = default(float); + float g = default(float); + float b = default(float); + float a = default(float); + + if(!LuaAPI.xlua_unpack_float4(buff, offset, out r, out g, out b, out a)) + { + return false; + } + field.r = r; + field.g = g; + field.b = b; + field.a = a; + + + return true; + } + + + public static void UnPack(ObjectTranslator translator, RealStatePtr L, int idx, out UnityEngine.Quaternion val) + { + val = new UnityEngine.Quaternion(); + int top = LuaAPI.lua_gettop(L); + + if (Utils.LoadField(L, idx, "x")) + { + + translator.Get(L, top + 1, out val.x); + + } + LuaAPI.lua_pop(L, 1); + + if (Utils.LoadField(L, idx, "y")) + { + + translator.Get(L, top + 1, out val.y); + + } + LuaAPI.lua_pop(L, 1); + + if (Utils.LoadField(L, idx, "z")) + { + + translator.Get(L, top + 1, out val.z); + + } + LuaAPI.lua_pop(L, 1); + + if (Utils.LoadField(L, idx, "w")) + { + + translator.Get(L, top + 1, out val.w); + + } + LuaAPI.lua_pop(L, 1); + + } + + public static bool Pack(IntPtr buff, int offset, UnityEngine.Quaternion field) + { + + if(!LuaAPI.xlua_pack_float4(buff, offset, field.x, field.y, field.z, field.w)) + { + return false; + } + + return true; + } + public static bool UnPack(IntPtr buff, int offset, out UnityEngine.Quaternion field) + { + field = default(UnityEngine.Quaternion); + + float x = default(float); + float y = default(float); + float z = default(float); + float w = default(float); + + if(!LuaAPI.xlua_unpack_float4(buff, offset, out x, out y, out z, out w)) + { + return false; + } + field.x = x; + field.y = y; + field.z = z; + field.w = w; + + + return true; + } + + + public static void UnPack(ObjectTranslator translator, RealStatePtr L, int idx, out UnityEngine.Ray val) + { + val = new UnityEngine.Ray(); + int top = LuaAPI.lua_gettop(L); + + if (Utils.LoadField(L, idx, "origin")) + { + + var origin = val.origin; + translator.Get(L, top + 1, out origin); + val.origin = origin; + + } + LuaAPI.lua_pop(L, 1); + + if (Utils.LoadField(L, idx, "direction")) + { + + var direction = val.direction; + translator.Get(L, top + 1, out direction); + val.direction = direction; + + } + LuaAPI.lua_pop(L, 1); + + } + + public static bool Pack(IntPtr buff, int offset, UnityEngine.Ray field) + { + + if(!Pack(buff, offset, field.origin)) + { + return false; + } + + if(!Pack(buff, offset + 12, field.direction)) + { + return false; + } + + return true; + } + public static bool UnPack(IntPtr buff, int offset, out UnityEngine.Ray field) + { + field = default(UnityEngine.Ray); + + var origin = field.origin; + if(!UnPack(buff, offset, out origin)) + { + return false; + } + field.origin = origin; + + var direction = field.direction; + if(!UnPack(buff, offset + 12, out direction)) + { + return false; + } + field.direction = direction; + + return true; + } + + + public static void UnPack(ObjectTranslator translator, RealStatePtr L, int idx, out UnityEngine.Bounds val) + { + val = new UnityEngine.Bounds(); + int top = LuaAPI.lua_gettop(L); + + if (Utils.LoadField(L, idx, "center")) + { + + var center = val.center; + translator.Get(L, top + 1, out center); + val.center = center; + + } + LuaAPI.lua_pop(L, 1); + + if (Utils.LoadField(L, idx, "extents")) + { + + var extents = val.extents; + translator.Get(L, top + 1, out extents); + val.extents = extents; + + } + LuaAPI.lua_pop(L, 1); + + } + + public static bool Pack(IntPtr buff, int offset, UnityEngine.Bounds field) + { + + if(!Pack(buff, offset, field.center)) + { + return false; + } + + if(!Pack(buff, offset + 12, field.extents)) + { + return false; + } + + return true; + } + public static bool UnPack(IntPtr buff, int offset, out UnityEngine.Bounds field) + { + field = default(UnityEngine.Bounds); + + var center = field.center; + if(!UnPack(buff, offset, out center)) + { + return false; + } + field.center = center; + + var extents = field.extents; + if(!UnPack(buff, offset + 12, out extents)) + { + return false; + } + field.extents = extents; + + return true; + } + + + public static void UnPack(ObjectTranslator translator, RealStatePtr L, int idx, out UnityEngine.Ray2D val) + { + val = new UnityEngine.Ray2D(); + int top = LuaAPI.lua_gettop(L); + + if (Utils.LoadField(L, idx, "origin")) + { + + var origin = val.origin; + translator.Get(L, top + 1, out origin); + val.origin = origin; + + } + LuaAPI.lua_pop(L, 1); + + if (Utils.LoadField(L, idx, "direction")) + { + + var direction = val.direction; + translator.Get(L, top + 1, out direction); + val.direction = direction; + + } + LuaAPI.lua_pop(L, 1); + + } + + public static bool Pack(IntPtr buff, int offset, UnityEngine.Ray2D field) + { + + if(!Pack(buff, offset, field.origin)) + { + return false; + } + + if(!Pack(buff, offset + 8, field.direction)) + { + return false; + } + + return true; + } + public static bool UnPack(IntPtr buff, int offset, out UnityEngine.Ray2D field) + { + field = default(UnityEngine.Ray2D); + + var origin = field.origin; + if(!UnPack(buff, offset, out origin)) + { + return false; + } + field.origin = origin; + + var direction = field.direction; + if(!UnPack(buff, offset + 8, out direction)) + { + return false; + } + field.direction = direction; + + return true; + } + + } +} \ No newline at end of file diff --git a/Assets/XLua/Gen/ParticleUVAnimationWrap.cs b/Assets/XLua/Gen/ParticleUVAnimationWrap.cs new file mode 100644 index 000000000..f60492971 --- /dev/null +++ b/Assets/XLua/Gen/ParticleUVAnimationWrap.cs @@ -0,0 +1,237 @@ +#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 ParticleUVAnimationWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(ParticleUVAnimation); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 4, 4); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Play", _m_Play); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "particle", _g_get_particle); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "texST", _g_get_texST); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "running", _g_get_running); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fps", _g_get_fps); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "particle", _s_set_particle); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "texST", _s_set_texST); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "running", _s_set_running); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fps", _s_set_fps); + + + 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 ParticleUVAnimation(); + 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 ParticleUVAnimation constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Play(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ParticleUVAnimation gen_to_be_invoked = (ParticleUVAnimation)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Play( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_particle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ParticleUVAnimation gen_to_be_invoked = (ParticleUVAnimation)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.particle); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_texST(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ParticleUVAnimation gen_to_be_invoked = (ParticleUVAnimation)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector4(L, gen_to_be_invoked.texST); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_running(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ParticleUVAnimation gen_to_be_invoked = (ParticleUVAnimation)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.running); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fps(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ParticleUVAnimation gen_to_be_invoked = (ParticleUVAnimation)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.fps); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_particle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ParticleUVAnimation gen_to_be_invoked = (ParticleUVAnimation)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.particle = (UnityEngine.ParticleSystem)translator.GetObject(L, 2, typeof(UnityEngine.ParticleSystem)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_texST(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ParticleUVAnimation gen_to_be_invoked = (ParticleUVAnimation)translator.FastGetCSObj(L, 1); + UnityEngine.Vector4 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.texST = 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_running(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ParticleUVAnimation gen_to_be_invoked = (ParticleUVAnimation)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.running = 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_fps(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ParticleUVAnimation gen_to_be_invoked = (ParticleUVAnimation)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.fps = (float)LuaAPI.lua_tonumber(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/ProductInfoWrap.cs b/Assets/XLua/Gen/ProductInfoWrap.cs new file mode 100644 index 000000000..998c3f654 --- /dev/null +++ b/Assets/XLua/Gen/ProductInfoWrap.cs @@ -0,0 +1,149 @@ +#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 ProductInfoWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(ProductInfo); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 2); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "productId", _g_get_productId); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "type", _g_get_type); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "productId", _s_set_productId); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "type", _s_set_type); + + + 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) + { + translator.Push(L, default(ProductInfo)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to ProductInfo constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_productId(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ProductInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.productId); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_type(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ProductInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEnginePurchasingProductType(L, gen_to_be_invoked.type); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_productId(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ProductInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.productId = LuaAPI.lua_tostring(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_type(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ProductInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Purchasing.ProductType gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.type = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/Security_XXTEAWrap.cs b/Assets/XLua/Gen/Security_XXTEAWrap.cs new file mode 100644 index 000000000..85ba66a84 --- /dev/null +++ b/Assets/XLua/Gen/Security_XXTEAWrap.cs @@ -0,0 +1,373 @@ +#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 SecurityXXTEAWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(Security.XXTEA); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 7, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Encrypt", _m_Encrypt_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "EncryptToBase64String", _m_EncryptToBase64String_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Decrypt", _m_Decrypt_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "DecryptBase64String", _m_DecryptBase64String_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "DecryptToString", _m_DecryptToString_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "DecryptBase64StringToString", _m_DecryptBase64StringToString_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "Security.XXTEA does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Encrypt_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + byte[] _data = LuaAPI.lua_tobytes(L, 1); + byte[] _key = LuaAPI.lua_tobytes(L, 2); + + var gen_ret = Security.XXTEA.Encrypt( _data, _key ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _data = LuaAPI.lua_tostring(L, 1); + byte[] _key = LuaAPI.lua_tobytes(L, 2); + + var gen_ret = Security.XXTEA.Encrypt( _data, _key ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + byte[] _data = LuaAPI.lua_tobytes(L, 1); + string _key = LuaAPI.lua_tostring(L, 2); + + var gen_ret = Security.XXTEA.Encrypt( _data, _key ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _data = LuaAPI.lua_tostring(L, 1); + string _key = LuaAPI.lua_tostring(L, 2); + + var gen_ret = Security.XXTEA.Encrypt( _data, _key ); + LuaAPI.lua_pushstring(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 Security.XXTEA.Encrypt!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_EncryptToBase64String_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + byte[] _data = LuaAPI.lua_tobytes(L, 1); + byte[] _key = LuaAPI.lua_tobytes(L, 2); + + var gen_ret = Security.XXTEA.EncryptToBase64String( _data, _key ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _data = LuaAPI.lua_tostring(L, 1); + byte[] _key = LuaAPI.lua_tobytes(L, 2); + + var gen_ret = Security.XXTEA.EncryptToBase64String( _data, _key ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + byte[] _data = LuaAPI.lua_tobytes(L, 1); + string _key = LuaAPI.lua_tostring(L, 2); + + var gen_ret = Security.XXTEA.EncryptToBase64String( _data, _key ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _data = LuaAPI.lua_tostring(L, 1); + string _key = LuaAPI.lua_tostring(L, 2); + + var gen_ret = Security.XXTEA.EncryptToBase64String( _data, _key ); + LuaAPI.lua_pushstring(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 Security.XXTEA.EncryptToBase64String!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Decrypt_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + byte[] _data = LuaAPI.lua_tobytes(L, 1); + byte[] _key = LuaAPI.lua_tobytes(L, 2); + + var gen_ret = Security.XXTEA.Decrypt( _data, _key ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + byte[] _data = LuaAPI.lua_tobytes(L, 1); + string _key = LuaAPI.lua_tostring(L, 2); + + var gen_ret = Security.XXTEA.Decrypt( _data, _key ); + LuaAPI.lua_pushstring(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 Security.XXTEA.Decrypt!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DecryptBase64String_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _data = LuaAPI.lua_tostring(L, 1); + byte[] _key = LuaAPI.lua_tobytes(L, 2); + + var gen_ret = Security.XXTEA.DecryptBase64String( _data, _key ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _data = LuaAPI.lua_tostring(L, 1); + string _key = LuaAPI.lua_tostring(L, 2); + + var gen_ret = Security.XXTEA.DecryptBase64String( _data, _key ); + LuaAPI.lua_pushstring(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 Security.XXTEA.DecryptBase64String!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DecryptToString_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + byte[] _data = LuaAPI.lua_tobytes(L, 1); + byte[] _key = LuaAPI.lua_tobytes(L, 2); + + var gen_ret = Security.XXTEA.DecryptToString( _data, _key ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + byte[] _data = LuaAPI.lua_tobytes(L, 1); + string _key = LuaAPI.lua_tostring(L, 2); + + var gen_ret = Security.XXTEA.DecryptToString( _data, _key ); + LuaAPI.lua_pushstring(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 Security.XXTEA.DecryptToString!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DecryptBase64StringToString_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _data = LuaAPI.lua_tostring(L, 1); + byte[] _key = LuaAPI.lua_tobytes(L, 2); + + var gen_ret = Security.XXTEA.DecryptBase64StringToString( _data, _key ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _data = LuaAPI.lua_tostring(L, 1); + string _key = LuaAPI.lua_tostring(L, 2); + + var gen_ret = Security.XXTEA.DecryptBase64StringToString( _data, _key ); + LuaAPI.lua_pushstring(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 Security.XXTEA.DecryptBase64StringToString!"); + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/SignInWithAppleTest_CallbacksWrap.cs b/Assets/XLua/Gen/SignInWithAppleTest_CallbacksWrap.cs new file mode 100644 index 000000000..8e419489d --- /dev/null +++ b/Assets/XLua/Gen/SignInWithAppleTest_CallbacksWrap.cs @@ -0,0 +1,140 @@ +#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 SignInWithAppleTest_CallbacksWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(SignInWithAppleTest_Callbacks); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ButtonPress", _m_ButtonPress); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CredentialButton", _m_CredentialButton); + + + + + + 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 SignInWithAppleTest_Callbacks(); + 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 SignInWithAppleTest_Callbacks constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ButtonPress(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + SignInWithAppleTest_Callbacks gen_to_be_invoked = (SignInWithAppleTest_Callbacks)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ButtonPress( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CredentialButton(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + SignInWithAppleTest_Callbacks gen_to_be_invoked = (SignInWithAppleTest_Callbacks)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CredentialButton( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/SignInWithAppleTest_EventSystemWrap.cs b/Assets/XLua/Gen/SignInWithAppleTest_EventSystemWrap.cs new file mode 100644 index 000000000..258cd1ecf --- /dev/null +++ b/Assets/XLua/Gen/SignInWithAppleTest_EventSystemWrap.cs @@ -0,0 +1,227 @@ +#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 SignInWithAppleTest_EventSystemWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(SignInWithAppleTest_EventSystem); + Utils.BeginObjectRegister(type, L, translator, 0, 5, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ButtonPress", _m_ButtonPress); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CredentialButton", _m_CredentialButton); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnCredentialState", _m_OnCredentialState); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnLogin", _m_OnLogin); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnError", _m_OnError); + + + + + + 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 SignInWithAppleTest_EventSystem(); + 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 SignInWithAppleTest_EventSystem constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ButtonPress(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + SignInWithAppleTest_EventSystem gen_to_be_invoked = (SignInWithAppleTest_EventSystem)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ButtonPress( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CredentialButton(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + SignInWithAppleTest_EventSystem gen_to_be_invoked = (SignInWithAppleTest_EventSystem)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CredentialButton( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnCredentialState(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + SignInWithAppleTest_EventSystem gen_to_be_invoked = (SignInWithAppleTest_EventSystem)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.SignInWithApple.SignInWithApple.CallbackArgs _args;translator.Get(L, 2, out _args); + + gen_to_be_invoked.OnCredentialState( _args ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnLogin(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + SignInWithAppleTest_EventSystem gen_to_be_invoked = (SignInWithAppleTest_EventSystem)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.SignInWithApple.SignInWithApple.CallbackArgs _args;translator.Get(L, 2, out _args); + + gen_to_be_invoked.OnLogin( _args ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnError(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + SignInWithAppleTest_EventSystem gen_to_be_invoked = (SignInWithAppleTest_EventSystem)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.SignInWithApple.SignInWithApple.CallbackArgs _args;translator.Get(L, 2, out _args); + + gen_to_be_invoked.OnError( _args ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/Spine_AnimationStateDataWrap.cs b/Assets/XLua/Gen/Spine_AnimationStateDataWrap.cs new file mode 100644 index 000000000..804d7d0fe --- /dev/null +++ b/Assets/XLua/Gen/Spine_AnimationStateDataWrap.cs @@ -0,0 +1,209 @@ +#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 SpineAnimationStateDataWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(Spine.AnimationStateData); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 2, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMix", _m_SetMix); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetMix", _m_GetMix); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "SkeletonData", _g_get_SkeletonData); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "DefaultMix", _g_get_DefaultMix); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "DefaultMix", _s_set_DefaultMix); + + + 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) == 2 && translator.Assignable(L, 2)) + { + Spine.SkeletonData _skeletonData = (Spine.SkeletonData)translator.GetObject(L, 2, typeof(Spine.SkeletonData)); + + var gen_ret = new Spine.AnimationStateData(_skeletonData); + 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 Spine.AnimationStateData constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMix(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.AnimationStateData gen_to_be_invoked = (Spine.AnimationStateData)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& (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)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + string _fromName = LuaAPI.lua_tostring(L, 2); + string _toName = LuaAPI.lua_tostring(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.SetMix( _fromName, _toName, _duration ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + Spine.Animation _from = (Spine.Animation)translator.GetObject(L, 2, typeof(Spine.Animation)); + Spine.Animation _to = (Spine.Animation)translator.GetObject(L, 3, typeof(Spine.Animation)); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.SetMix( _from, _to, _duration ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to Spine.AnimationStateData.SetMix!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetMix(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.AnimationStateData gen_to_be_invoked = (Spine.AnimationStateData)translator.FastGetCSObj(L, 1); + + + + { + Spine.Animation _from = (Spine.Animation)translator.GetObject(L, 2, typeof(Spine.Animation)); + Spine.Animation _to = (Spine.Animation)translator.GetObject(L, 3, typeof(Spine.Animation)); + + var gen_ret = gen_to_be_invoked.GetMix( _from, _to ); + LuaAPI.lua_pushnumber(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_SkeletonData(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.AnimationStateData gen_to_be_invoked = (Spine.AnimationStateData)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.SkeletonData); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DefaultMix(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.AnimationStateData gen_to_be_invoked = (Spine.AnimationStateData)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.DefaultMix); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_DefaultMix(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.AnimationStateData gen_to_be_invoked = (Spine.AnimationStateData)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.DefaultMix = (float)LuaAPI.lua_tonumber(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/Spine_AnimationStateData_AnimationPairComparerWrap.cs b/Assets/XLua/Gen/Spine_AnimationStateData_AnimationPairComparerWrap.cs new file mode 100644 index 000000000..aae751612 --- /dev/null +++ b/Assets/XLua/Gen/Spine_AnimationStateData_AnimationPairComparerWrap.cs @@ -0,0 +1,85 @@ +#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 SpineAnimationStateDataAnimationPairComparerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(Spine.AnimationStateData.AnimationPairComparer); + 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.RegisterObject(L, translator, Utils.CLS_IDX, "Instance", Spine.AnimationStateData.AnimationPairComparer.Instance); + + + + + 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 Spine.AnimationStateData.AnimationPairComparer(); + 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 Spine.AnimationStateData.AnimationPairComparer constructor!"); + + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/Spine_AnimationStateData_AnimationPairWrap.cs b/Assets/XLua/Gen/Spine_AnimationStateData_AnimationPairWrap.cs new file mode 100644 index 000000000..60cb68e5a --- /dev/null +++ b/Assets/XLua/Gen/Spine_AnimationStateData_AnimationPairWrap.cs @@ -0,0 +1,153 @@ +#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 SpineAnimationStateDataAnimationPairWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(Spine.AnimationStateData.AnimationPair); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 2, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "a1", _g_get_a1); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "a2", _g_get_a2); + + + + 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 && translator.Assignable(L, 2) && translator.Assignable(L, 3)) + { + Spine.Animation _a1 = (Spine.Animation)translator.GetObject(L, 2, typeof(Spine.Animation)); + Spine.Animation _a2 = (Spine.Animation)translator.GetObject(L, 3, typeof(Spine.Animation)); + + var gen_ret = new Spine.AnimationStateData.AnimationPair(_a1, _a2); + translator.Push(L, gen_ret); + + return 1; + } + + if (LuaAPI.lua_gettop(L) == 1) + { + translator.Push(L, default(Spine.AnimationStateData.AnimationPair)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to Spine.AnimationStateData.AnimationPair constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.AnimationStateData.AnimationPair gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.ToString( ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_a1(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.AnimationStateData.AnimationPair gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.a1); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_a2(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.AnimationStateData.AnimationPair gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.a2); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/Spine_AnimationStateWrap.cs b/Assets/XLua/Gen/Spine_AnimationStateWrap.cs new file mode 100644 index 000000000..b6dc2de66 --- /dev/null +++ b/Assets/XLua/Gen/Spine_AnimationStateWrap.cs @@ -0,0 +1,900 @@ +#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 SpineAnimationStateWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(Spine.AnimationState); + Utils.BeginObjectRegister(type, L, translator, 0, 22, 3, 2); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AssignEventSubscribersFrom", _m_AssignEventSubscribersFrom); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddEventSubscribersFrom", _m_AddEventSubscribersFrom); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Update", _m_Update); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Apply", _m_Apply); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ApplyEventTimelinesOnly", _m_ApplyEventTimelinesOnly); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearTracks", _m_ClearTracks); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearTrack", _m_ClearTrack); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAnimation", _m_SetAnimation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddAnimation", _m_AddAnimation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetEmptyAnimation", _m_SetEmptyAnimation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddEmptyAnimation", _m_AddEmptyAnimation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetEmptyAnimations", _m_SetEmptyAnimations); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearNext", _m_ClearNext); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetCurrent", _m_GetCurrent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearListenerNotifications", _m_ClearListenerNotifications); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Start", _e_Start); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Interrupt", _e_Interrupt); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "End", _e_End); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Dispose", _e_Dispose); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Complete", _e_Complete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Event", _e_Event); + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "TimeScale", _g_get_TimeScale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Data", _g_get_Data); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Tracks", _g_get_Tracks); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "TimeScale", _s_set_TimeScale); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Data", _s_set_Data); + + + 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) == 2 && translator.Assignable(L, 2)) + { + Spine.AnimationStateData _data = (Spine.AnimationStateData)translator.GetObject(L, 2, typeof(Spine.AnimationStateData)); + + var gen_ret = new Spine.AnimationState(_data); + 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 Spine.AnimationState constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AssignEventSubscribersFrom(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.AnimationState gen_to_be_invoked = (Spine.AnimationState)translator.FastGetCSObj(L, 1); + + + + { + Spine.AnimationState _src = (Spine.AnimationState)translator.GetObject(L, 2, typeof(Spine.AnimationState)); + + gen_to_be_invoked.AssignEventSubscribersFrom( _src ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddEventSubscribersFrom(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.AnimationState gen_to_be_invoked = (Spine.AnimationState)translator.FastGetCSObj(L, 1); + + + + { + Spine.AnimationState _src = (Spine.AnimationState)translator.GetObject(L, 2, typeof(Spine.AnimationState)); + + gen_to_be_invoked.AddEventSubscribersFrom( _src ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Update(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.AnimationState gen_to_be_invoked = (Spine.AnimationState)translator.FastGetCSObj(L, 1); + + + + { + float _delta = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.Update( _delta ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Apply(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.AnimationState gen_to_be_invoked = (Spine.AnimationState)translator.FastGetCSObj(L, 1); + + + + { + Spine.Skeleton _skeleton = (Spine.Skeleton)translator.GetObject(L, 2, typeof(Spine.Skeleton)); + + var gen_ret = gen_to_be_invoked.Apply( _skeleton ); + 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_ApplyEventTimelinesOnly(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.AnimationState gen_to_be_invoked = (Spine.AnimationState)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + Spine.Skeleton _skeleton = (Spine.Skeleton)translator.GetObject(L, 2, typeof(Spine.Skeleton)); + bool _issueEvents = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.ApplyEventTimelinesOnly( _skeleton, _issueEvents ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + Spine.Skeleton _skeleton = (Spine.Skeleton)translator.GetObject(L, 2, typeof(Spine.Skeleton)); + + var gen_ret = gen_to_be_invoked.ApplyEventTimelinesOnly( _skeleton ); + LuaAPI.lua_pushboolean(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 Spine.AnimationState.ApplyEventTimelinesOnly!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearTracks(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.AnimationState gen_to_be_invoked = (Spine.AnimationState)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearTracks( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearTrack(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.AnimationState gen_to_be_invoked = (Spine.AnimationState)translator.FastGetCSObj(L, 1); + + + + { + int _trackIndex = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.ClearTrack( _trackIndex ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAnimation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.AnimationState gen_to_be_invoked = (Spine.AnimationState)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + int _trackIndex = LuaAPI.xlua_tointeger(L, 2); + string _animationName = LuaAPI.lua_tostring(L, 3); + bool _loop = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.SetAnimation( _trackIndex, _animationName, _loop ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + int _trackIndex = LuaAPI.xlua_tointeger(L, 2); + Spine.Animation _animation = (Spine.Animation)translator.GetObject(L, 3, typeof(Spine.Animation)); + bool _loop = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.SetAnimation( _trackIndex, _animation, _loop ); + 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 Spine.AnimationState.SetAnimation!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddAnimation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.AnimationState gen_to_be_invoked = (Spine.AnimationState)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int _trackIndex = LuaAPI.xlua_tointeger(L, 2); + string _animationName = LuaAPI.lua_tostring(L, 3); + bool _loop = LuaAPI.lua_toboolean(L, 4); + float _delay = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = gen_to_be_invoked.AddAnimation( _trackIndex, _animationName, _loop, _delay ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int _trackIndex = LuaAPI.xlua_tointeger(L, 2); + Spine.Animation _animation = (Spine.Animation)translator.GetObject(L, 3, typeof(Spine.Animation)); + bool _loop = LuaAPI.lua_toboolean(L, 4); + float _delay = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = gen_to_be_invoked.AddAnimation( _trackIndex, _animation, _loop, _delay ); + 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 Spine.AnimationState.AddAnimation!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetEmptyAnimation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.AnimationState gen_to_be_invoked = (Spine.AnimationState)translator.FastGetCSObj(L, 1); + + + + { + int _trackIndex = LuaAPI.xlua_tointeger(L, 2); + float _mixDuration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.SetEmptyAnimation( _trackIndex, _mixDuration ); + 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_AddEmptyAnimation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.AnimationState gen_to_be_invoked = (Spine.AnimationState)translator.FastGetCSObj(L, 1); + + + + { + int _trackIndex = LuaAPI.xlua_tointeger(L, 2); + float _mixDuration = (float)LuaAPI.lua_tonumber(L, 3); + float _delay = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.AddEmptyAnimation( _trackIndex, _mixDuration, _delay ); + 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_SetEmptyAnimations(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.AnimationState gen_to_be_invoked = (Spine.AnimationState)translator.FastGetCSObj(L, 1); + + + + { + float _mixDuration = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.SetEmptyAnimations( _mixDuration ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearNext(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.AnimationState gen_to_be_invoked = (Spine.AnimationState)translator.FastGetCSObj(L, 1); + + + + { + Spine.TrackEntry _entry = (Spine.TrackEntry)translator.GetObject(L, 2, typeof(Spine.TrackEntry)); + + gen_to_be_invoked.ClearNext( _entry ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetCurrent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.AnimationState gen_to_be_invoked = (Spine.AnimationState)translator.FastGetCSObj(L, 1); + + + + { + int _trackIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetCurrent( _trackIndex ); + 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_ClearListenerNotifications(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.AnimationState gen_to_be_invoked = (Spine.AnimationState)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearListenerNotifications( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.AnimationState gen_to_be_invoked = (Spine.AnimationState)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_TimeScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.AnimationState gen_to_be_invoked = (Spine.AnimationState)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.TimeScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Data(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.AnimationState gen_to_be_invoked = (Spine.AnimationState)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Data); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Tracks(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.AnimationState gen_to_be_invoked = (Spine.AnimationState)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Tracks); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_TimeScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.AnimationState gen_to_be_invoked = (Spine.AnimationState)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.TimeScale = (float)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_Data(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.AnimationState gen_to_be_invoked = (Spine.AnimationState)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Data = (Spine.AnimationStateData)translator.GetObject(L, 2, typeof(Spine.AnimationStateData)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_Start(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.AnimationState gen_to_be_invoked = (Spine.AnimationState)translator.FastGetCSObj(L, 1); + Spine.AnimationState.TrackEntryDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.AnimationState.TrackEntryDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.Start += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.Start -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.AnimationState.Start!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_Interrupt(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.AnimationState gen_to_be_invoked = (Spine.AnimationState)translator.FastGetCSObj(L, 1); + Spine.AnimationState.TrackEntryDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.AnimationState.TrackEntryDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.Interrupt += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.Interrupt -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.AnimationState.Interrupt!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_End(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.AnimationState gen_to_be_invoked = (Spine.AnimationState)translator.FastGetCSObj(L, 1); + Spine.AnimationState.TrackEntryDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.AnimationState.TrackEntryDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.End += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.End -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.AnimationState.End!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_Dispose(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.AnimationState gen_to_be_invoked = (Spine.AnimationState)translator.FastGetCSObj(L, 1); + Spine.AnimationState.TrackEntryDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.AnimationState.TrackEntryDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.Dispose += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.Dispose -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.AnimationState.Dispose!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_Complete(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.AnimationState gen_to_be_invoked = (Spine.AnimationState)translator.FastGetCSObj(L, 1); + Spine.AnimationState.TrackEntryDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.AnimationState.TrackEntryDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.Complete += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.Complete -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.AnimationState.Complete!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_Event(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.AnimationState gen_to_be_invoked = (Spine.AnimationState)translator.FastGetCSObj(L, 1); + Spine.AnimationState.TrackEntryEventDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.AnimationState.TrackEntryEventDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.Event += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.Event -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.AnimationState.Event!"); + return 0; + } + + + + } +} diff --git a/Assets/XLua/Gen/Spine_AnimationWrap.cs b/Assets/XLua/Gen/Spine_AnimationWrap.cs new file mode 100644 index 000000000..f4d4a50bb --- /dev/null +++ b/Assets/XLua/Gen/Spine_AnimationWrap.cs @@ -0,0 +1,288 @@ +#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 SpineAnimationWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(Spine.Animation); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 3, 2); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTimelines", _m_SetTimelines); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasTimeline", _m_HasTimeline); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Apply", _m_Apply); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Timelines", _g_get_Timelines); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Duration", _g_get_Duration); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Name", _g_get_Name); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Timelines", _s_set_Timelines); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Duration", _s_set_Duration); + + + 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) == 4 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING) && translator.Assignable>(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + string _name = LuaAPI.lua_tostring(L, 2); + Spine.ExposedList _timelines = (Spine.ExposedList)translator.GetObject(L, 3, typeof(Spine.ExposedList)); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = new Spine.Animation(_name, _timelines, _duration); + 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 Spine.Animation constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTimelines(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Animation gen_to_be_invoked = (Spine.Animation)translator.FastGetCSObj(L, 1); + + + + { + Spine.ExposedList _timelines = (Spine.ExposedList)translator.GetObject(L, 2, typeof(Spine.ExposedList)); + + gen_to_be_invoked.SetTimelines( _timelines ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasTimeline(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Animation gen_to_be_invoked = (Spine.Animation)translator.FastGetCSObj(L, 1); + + + + { + string[] _propertyIds = (string[])translator.GetObject(L, 2, typeof(string[])); + + var gen_ret = gen_to_be_invoked.HasTimeline( _propertyIds ); + 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_Apply(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Animation gen_to_be_invoked = (Spine.Animation)translator.FastGetCSObj(L, 1); + + + + { + Spine.Skeleton _skeleton = (Spine.Skeleton)translator.GetObject(L, 2, typeof(Spine.Skeleton)); + float _lastTime = (float)LuaAPI.lua_tonumber(L, 3); + float _time = (float)LuaAPI.lua_tonumber(L, 4); + bool _loop = LuaAPI.lua_toboolean(L, 5); + Spine.ExposedList _events = (Spine.ExposedList)translator.GetObject(L, 6, typeof(Spine.ExposedList)); + float _alpha = (float)LuaAPI.lua_tonumber(L, 7); + Spine.MixBlend _blend;translator.Get(L, 8, out _blend); + Spine.MixDirection _direction;translator.Get(L, 9, out _direction); + + gen_to_be_invoked.Apply( _skeleton, _lastTime, _time, _loop, _events, _alpha, _blend, _direction ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Animation gen_to_be_invoked = (Spine.Animation)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_Timelines(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Animation gen_to_be_invoked = (Spine.Animation)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Timelines); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Duration(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Animation gen_to_be_invoked = (Spine.Animation)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.Duration); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Name(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Animation gen_to_be_invoked = (Spine.Animation)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 _s_set_Timelines(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Animation gen_to_be_invoked = (Spine.Animation)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Timelines = (Spine.ExposedList)translator.GetObject(L, 2, typeof(Spine.ExposedList)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Duration(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Animation gen_to_be_invoked = (Spine.Animation)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Duration = (float)LuaAPI.lua_tonumber(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/Spine_MeshAttachmentWrap.cs b/Assets/XLua/Gen/Spine_MeshAttachmentWrap.cs new file mode 100644 index 000000000..bb6d4518f --- /dev/null +++ b/Assets/XLua/Gen/Spine_MeshAttachmentWrap.cs @@ -0,0 +1,688 @@ +#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 SpineMeshAttachmentWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(Spine.MeshAttachment); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 15, 15); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateRegion", _m_UpdateRegion); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ComputeWorldVertices", _m_ComputeWorldVertices); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "NewLinkedMesh", _m_NewLinkedMesh); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Copy", _m_Copy); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Region", _g_get_Region); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "HullLength", _g_get_HullLength); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "RegionUVs", _g_get_RegionUVs); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "UVs", _g_get_UVs); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Triangles", _g_get_Triangles); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "R", _g_get_R); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "G", _g_get_G); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "B", _g_get_B); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "A", _g_get_A); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Path", _g_get_Path); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Sequence", _g_get_Sequence); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ParentMesh", _g_get_ParentMesh); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Edges", _g_get_Edges); + 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, "Region", _s_set_Region); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "HullLength", _s_set_HullLength); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "RegionUVs", _s_set_RegionUVs); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "UVs", _s_set_UVs); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Triangles", _s_set_Triangles); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "R", _s_set_R); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "G", _s_set_G); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "B", _s_set_B); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "A", _s_set_A); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Path", _s_set_Path); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Sequence", _s_set_Sequence); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ParentMesh", _s_set_ParentMesh); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Edges", _s_set_Edges); + 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) == 2 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = new Spine.MeshAttachment(_name); + 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 Spine.MeshAttachment constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UpdateRegion(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.UpdateRegion( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ComputeWorldVertices(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 7&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)) + { + Spine.Slot _slot = (Spine.Slot)translator.GetObject(L, 2, typeof(Spine.Slot)); + int _start = LuaAPI.xlua_tointeger(L, 3); + int _count = LuaAPI.xlua_tointeger(L, 4); + float[] _worldVertices = (float[])translator.GetObject(L, 5, typeof(float[])); + int _offset = LuaAPI.xlua_tointeger(L, 6); + int _stride = LuaAPI.xlua_tointeger(L, 7); + + gen_to_be_invoked.ComputeWorldVertices( _slot, _start, _count, _worldVertices, _offset, _stride ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + Spine.Slot _slot = (Spine.Slot)translator.GetObject(L, 2, typeof(Spine.Slot)); + int _start = LuaAPI.xlua_tointeger(L, 3); + int _count = LuaAPI.xlua_tointeger(L, 4); + float[] _worldVertices = (float[])translator.GetObject(L, 5, typeof(float[])); + int _offset = LuaAPI.xlua_tointeger(L, 6); + + gen_to_be_invoked.ComputeWorldVertices( _slot, _start, _count, _worldVertices, _offset ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to Spine.MeshAttachment.ComputeWorldVertices!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_NewLinkedMesh(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.NewLinkedMesh( ); + 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_Copy(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Copy( ); + 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_Region(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Region); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_HullLength(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.HullLength); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_RegionUVs(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.RegionUVs); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UVs(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.UVs); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Triangles(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Triangles); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_R(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.R); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_G(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.G); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_B(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.B); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_A(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.A); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Path(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Path); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Sequence(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Sequence); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ParentMesh(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.ParentMesh); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Edges(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Edges); + } 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); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(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); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(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_Region(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Region = (Spine.TextureRegion)translator.GetObject(L, 2, typeof(Spine.TextureRegion)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_HullLength(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.HullLength = 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_RegionUVs(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.RegionUVs = (float[])translator.GetObject(L, 2, typeof(float[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_UVs(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.UVs = (float[])translator.GetObject(L, 2, typeof(float[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Triangles(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Triangles = (int[])translator.GetObject(L, 2, typeof(int[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_R(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.R = (float)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_G(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.G = (float)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_B(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.B = (float)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_A(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.A = (float)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_Path(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Path = 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_Sequence(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Sequence = (Spine.Sequence)translator.GetObject(L, 2, typeof(Spine.Sequence)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_ParentMesh(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ParentMesh = (Spine.MeshAttachment)translator.GetObject(L, 2, typeof(Spine.MeshAttachment)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Edges(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Edges = (int[])translator.GetObject(L, 2, typeof(int[])); + + } 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); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Width = (float)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_Height(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.MeshAttachment gen_to_be_invoked = (Spine.MeshAttachment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Height = (float)LuaAPI.lua_tonumber(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/Spine_RegionAttachmentWrap.cs b/Assets/XLua/Gen/Spine_RegionAttachmentWrap.cs new file mode 100644 index 000000000..39b327dd1 --- /dev/null +++ b/Assets/XLua/Gen/Spine_RegionAttachmentWrap.cs @@ -0,0 +1,671 @@ +#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 SpineRegionAttachmentWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(Spine.RegionAttachment); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 16, 14); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateRegion", _m_UpdateRegion); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ComputeWorldVertices", _m_ComputeWorldVertices); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Copy", _m_Copy); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "X", _g_get_X); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Y", _g_get_Y); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Rotation", _g_get_Rotation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ScaleX", _g_get_ScaleX); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ScaleY", _g_get_ScaleY); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Width", _g_get_Width); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Height", _g_get_Height); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "R", _g_get_R); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "G", _g_get_G); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "B", _g_get_B); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "A", _g_get_A); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Path", _g_get_Path); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Region", _g_get_Region); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Offset", _g_get_Offset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "UVs", _g_get_UVs); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Sequence", _g_get_Sequence); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "X", _s_set_X); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Y", _s_set_Y); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Rotation", _s_set_Rotation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ScaleX", _s_set_ScaleX); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ScaleY", _s_set_ScaleY); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Width", _s_set_Width); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Height", _s_set_Height); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "R", _s_set_R); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "G", _s_set_G); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "B", _s_set_B); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "A", _s_set_A); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Path", _s_set_Path); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Region", _s_set_Region); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Sequence", _s_set_Sequence); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 9, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BLX", Spine.RegionAttachment.BLX); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BLY", Spine.RegionAttachment.BLY); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ULX", Spine.RegionAttachment.ULX); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ULY", Spine.RegionAttachment.ULY); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "URX", Spine.RegionAttachment.URX); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "URY", Spine.RegionAttachment.URY); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BRX", Spine.RegionAttachment.BRX); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BRY", Spine.RegionAttachment.BRY); + + + + + 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) == 2 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = new Spine.RegionAttachment(_name); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && translator.Assignable(L, 2)) + { + Spine.RegionAttachment _other = (Spine.RegionAttachment)translator.GetObject(L, 2, typeof(Spine.RegionAttachment)); + + var gen_ret = new Spine.RegionAttachment(_other); + 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 Spine.RegionAttachment constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UpdateRegion(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.UpdateRegion( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ComputeWorldVertices(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 5&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + Spine.Slot _slot = (Spine.Slot)translator.GetObject(L, 2, typeof(Spine.Slot)); + float[] _worldVertices = (float[])translator.GetObject(L, 3, typeof(float[])); + int _offset = LuaAPI.xlua_tointeger(L, 4); + int _stride = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.ComputeWorldVertices( _slot, _worldVertices, _offset, _stride ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + Spine.Slot _slot = (Spine.Slot)translator.GetObject(L, 2, typeof(Spine.Slot)); + float[] _worldVertices = (float[])translator.GetObject(L, 3, typeof(float[])); + int _offset = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.ComputeWorldVertices( _slot, _worldVertices, _offset ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to Spine.RegionAttachment.ComputeWorldVertices!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Copy(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Copy( ); + 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_X(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.X); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Y(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.Y); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Rotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.Rotation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ScaleX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.ScaleX); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ScaleY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.ScaleY); + } 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); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(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); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(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 _g_get_R(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.R); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_G(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.G); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_B(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.B); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_A(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.A); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Path(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Path); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Region(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Region); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Offset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Offset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UVs(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.UVs); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Sequence(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Sequence); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_X(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.X = (float)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_Y(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Y = (float)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_Rotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Rotation = (float)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_ScaleX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ScaleX = (float)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_ScaleY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ScaleY = (float)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_Width(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Width = (float)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_Height(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Height = (float)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_R(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.R = (float)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_G(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.G = (float)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_B(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.B = (float)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_A(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.A = (float)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_Path(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Path = 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_Region(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Region = (Spine.TextureRegion)translator.GetObject(L, 2, typeof(Spine.TextureRegion)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Sequence(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.RegionAttachment gen_to_be_invoked = (Spine.RegionAttachment)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Sequence = (Spine.Sequence)translator.GetObject(L, 2, typeof(Spine.Sequence)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/Spine_SkeletonDataWrap.cs b/Assets/XLua/Gen/Spine_SkeletonDataWrap.cs new file mode 100644 index 000000000..2ac2f4084 --- /dev/null +++ b/Assets/XLua/Gen/Spine_SkeletonDataWrap.cs @@ -0,0 +1,1002 @@ +#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 SpineSkeletonDataWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(Spine.SkeletonData); + Utils.BeginObjectRegister(type, L, translator, 0, 10, 21, 19); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindBone", _m_FindBone); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindSlot", _m_FindSlot); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindSkin", _m_FindSkin); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindEvent", _m_FindEvent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindAnimation", _m_FindAnimation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindIkConstraint", _m_FindIkConstraint); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindTransformConstraint", _m_FindTransformConstraint); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindPathConstraint", _m_FindPathConstraint); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindPhysicsConstraint", _m_FindPhysicsConstraint); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Name", _g_get_Name); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Bones", _g_get_Bones); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Slots", _g_get_Slots); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Skins", _g_get_Skins); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "DefaultSkin", _g_get_DefaultSkin); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Events", _g_get_Events); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Animations", _g_get_Animations); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IkConstraints", _g_get_IkConstraints); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "TransformConstraints", _g_get_TransformConstraints); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PathConstraints", _g_get_PathConstraints); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PhysicsConstraints", _g_get_PhysicsConstraints); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "X", _g_get_X); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Y", _g_get_Y); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Width", _g_get_Width); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Height", _g_get_Height); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ReferenceScale", _g_get_ReferenceScale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Version", _g_get_Version); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Hash", _g_get_Hash); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ImagesPath", _g_get_ImagesPath); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AudioPath", _g_get_AudioPath); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Fps", _g_get_Fps); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Name", _s_set_Name); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Skins", _s_set_Skins); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "DefaultSkin", _s_set_DefaultSkin); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Events", _s_set_Events); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Animations", _s_set_Animations); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "IkConstraints", _s_set_IkConstraints); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "TransformConstraints", _s_set_TransformConstraints); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "PathConstraints", _s_set_PathConstraints); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "PhysicsConstraints", _s_set_PhysicsConstraints); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "X", _s_set_X); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Y", _s_set_Y); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Width", _s_set_Width); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Height", _s_set_Height); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ReferenceScale", _s_set_ReferenceScale); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Version", _s_set_Version); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Hash", _s_set_Hash); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ImagesPath", _s_set_ImagesPath); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "AudioPath", _s_set_AudioPath); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Fps", _s_set_Fps); + + + 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 Spine.SkeletonData(); + 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 Spine.SkeletonData constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FindBone(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + + + + { + string _boneName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.FindBone( _boneName ); + 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_FindSlot(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + + + + { + string _slotName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.FindSlot( _slotName ); + 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_FindSkin(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + + + + { + string _skinName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.FindSkin( _skinName ); + 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_FindEvent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + + + + { + string _eventDataName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.FindEvent( _eventDataName ); + 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_FindAnimation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + + + + { + string _animationName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.FindAnimation( _animationName ); + 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_FindIkConstraint(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + + + + { + string _constraintName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.FindIkConstraint( _constraintName ); + 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_FindTransformConstraint(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + + + + { + string _constraintName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.FindTransformConstraint( _constraintName ); + 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_FindPathConstraint(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + + + + { + string _constraintName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.FindPathConstraint( _constraintName ); + 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_FindPhysicsConstraint(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + + + + { + string _constraintName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.FindPhysicsConstraint( _constraintName ); + 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_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)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_Name(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)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_Bones(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Bones); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Slots(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Slots); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Skins(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Skins); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DefaultSkin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.DefaultSkin); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Events(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Events); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Animations(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Animations); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IkConstraints(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.IkConstraints); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_TransformConstraints(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.TransformConstraints); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PathConstraints(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.PathConstraints); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PhysicsConstraints(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.PhysicsConstraints); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_X(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.X); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Y(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.Y); + } 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); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(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); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(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 _g_get_ReferenceScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.ReferenceScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Version(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Version); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Hash(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Hash); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ImagesPath(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.ImagesPath); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AudioPath(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.AudioPath); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Fps(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.Fps); + } 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); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)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_Skins(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Skins = (Spine.ExposedList)translator.GetObject(L, 2, typeof(Spine.ExposedList)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_DefaultSkin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.DefaultSkin = (Spine.Skin)translator.GetObject(L, 2, typeof(Spine.Skin)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Events(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Events = (Spine.ExposedList)translator.GetObject(L, 2, typeof(Spine.ExposedList)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Animations(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Animations = (Spine.ExposedList)translator.GetObject(L, 2, typeof(Spine.ExposedList)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_IkConstraints(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.IkConstraints = (Spine.ExposedList)translator.GetObject(L, 2, typeof(Spine.ExposedList)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_TransformConstraints(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.TransformConstraints = (Spine.ExposedList)translator.GetObject(L, 2, typeof(Spine.ExposedList)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_PathConstraints(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.PathConstraints = (Spine.ExposedList)translator.GetObject(L, 2, typeof(Spine.ExposedList)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_PhysicsConstraints(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.PhysicsConstraints = (Spine.ExposedList)translator.GetObject(L, 2, typeof(Spine.ExposedList)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_X(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.X = (float)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_Y(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Y = (float)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_Width(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Width = (float)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_Height(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Height = (float)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_ReferenceScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ReferenceScale = (float)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_Version(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Version = 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_Hash(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Hash = 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_ImagesPath(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ImagesPath = 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_AudioPath(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.AudioPath = 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_Fps(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.SkeletonData gen_to_be_invoked = (Spine.SkeletonData)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Fps = (float)LuaAPI.lua_tonumber(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/Spine_SkeletonWrap.cs b/Assets/XLua/Gen/Spine_SkeletonWrap.cs new file mode 100644 index 000000000..c3b64a8be --- /dev/null +++ b/Assets/XLua/Gen/Spine_SkeletonWrap.cs @@ -0,0 +1,1201 @@ +#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 SpineSkeletonWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(Spine.Skeleton); + Utils.BeginObjectRegister(type, L, translator, 0, 19, 20, 10); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateCache", _m_UpdateCache); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateWorldTransform", _m_UpdateWorldTransform); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PhysicsTranslate", _m_PhysicsTranslate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PhysicsRotate", _m_PhysicsRotate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Update", _m_Update); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetToSetupPose", _m_SetToSetupPose); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetBonesToSetupPose", _m_SetBonesToSetupPose); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSlotsToSetupPose", _m_SetSlotsToSetupPose); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindBone", _m_FindBone); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindSlot", _m_FindSlot); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSkin", _m_SetSkin); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAttachment", _m_GetAttachment); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAttachment", _m_SetAttachment); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindIkConstraint", _m_FindIkConstraint); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindTransformConstraint", _m_FindTransformConstraint); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindPathConstraint", _m_FindPathConstraint); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindPhysicsConstraint", _m_FindPhysicsConstraint); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetBounds", _m_GetBounds); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Data", _g_get_Data); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Bones", _g_get_Bones); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "UpdateCacheList", _g_get_UpdateCacheList); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Slots", _g_get_Slots); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "DrawOrder", _g_get_DrawOrder); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IkConstraints", _g_get_IkConstraints); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PathConstraints", _g_get_PathConstraints); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PhysicsConstraints", _g_get_PhysicsConstraints); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "TransformConstraints", _g_get_TransformConstraints); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Skin", _g_get_Skin); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "R", _g_get_R); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "G", _g_get_G); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "B", _g_get_B); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "A", _g_get_A); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "X", _g_get_X); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Y", _g_get_Y); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ScaleX", _g_get_ScaleX); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ScaleY", _g_get_ScaleY); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Time", _g_get_Time); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "RootBone", _g_get_RootBone); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Skin", _s_set_Skin); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "R", _s_set_R); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "G", _s_set_G); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "B", _s_set_B); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "A", _s_set_A); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "X", _s_set_X); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Y", _s_set_Y); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ScaleX", _s_set_ScaleX); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ScaleY", _s_set_ScaleY); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Time", _s_set_Time); + + + 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) == 2 && translator.Assignable(L, 2)) + { + Spine.SkeletonData _data = (Spine.SkeletonData)translator.GetObject(L, 2, typeof(Spine.SkeletonData)); + + var gen_ret = new Spine.Skeleton(_data); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && translator.Assignable(L, 2)) + { + Spine.Skeleton _skeleton = (Spine.Skeleton)translator.GetObject(L, 2, typeof(Spine.Skeleton)); + + var gen_ret = new Spine.Skeleton(_skeleton); + 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 Spine.Skeleton constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UpdateCache(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.UpdateCache( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UpdateWorldTransform(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + Spine.Skeleton.Physics _physics;translator.Get(L, 2, out _physics); + + gen_to_be_invoked.UpdateWorldTransform( _physics ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + Spine.Skeleton.Physics _physics;translator.Get(L, 2, out _physics); + Spine.Bone _parent = (Spine.Bone)translator.GetObject(L, 3, typeof(Spine.Bone)); + + gen_to_be_invoked.UpdateWorldTransform( _physics, _parent ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to Spine.Skeleton.UpdateWorldTransform!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PhysicsTranslate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + + + + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.PhysicsTranslate( _x, _y ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PhysicsRotate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + + + + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _degrees = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.PhysicsRotate( _x, _y, _degrees ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Update(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + + + + { + float _delta = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.Update( _delta ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetToSetupPose(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetToSetupPose( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetBonesToSetupPose(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetBonesToSetupPose( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSlotsToSetupPose(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetSlotsToSetupPose( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FindBone(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + + + + { + string _boneName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.FindBone( _boneName ); + 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_FindSlot(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + + + + { + string _slotName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.FindSlot( _slotName ); + 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_SetSkin(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _skinName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SetSkin( _skinName ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + Spine.Skin _newSkin = (Spine.Skin)translator.GetObject(L, 2, typeof(Spine.Skin)); + + gen_to_be_invoked.SetSkin( _newSkin ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to Spine.Skeleton.SetSkin!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetAttachment(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + int _slotIndex = LuaAPI.xlua_tointeger(L, 2); + string _attachmentName = LuaAPI.lua_tostring(L, 3); + + var gen_ret = gen_to_be_invoked.GetAttachment( _slotIndex, _attachmentName ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 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 _slotName = LuaAPI.lua_tostring(L, 2); + string _attachmentName = LuaAPI.lua_tostring(L, 3); + + var gen_ret = gen_to_be_invoked.GetAttachment( _slotName, _attachmentName ); + 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 Spine.Skeleton.GetAttachment!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAttachment(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + + + + { + string _slotName = LuaAPI.lua_tostring(L, 2); + string _attachmentName = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.SetAttachment( _slotName, _attachmentName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FindIkConstraint(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + + + + { + string _constraintName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.FindIkConstraint( _constraintName ); + 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_FindTransformConstraint(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + + + + { + string _constraintName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.FindTransformConstraint( _constraintName ); + 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_FindPathConstraint(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + + + + { + string _constraintName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.FindPathConstraint( _constraintName ); + 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_FindPhysicsConstraint(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + + + + { + string _constraintName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.FindPhysicsConstraint( _constraintName ); + 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_GetBounds(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + float _x; + float _y; + float _width; + float _height; + float[] _vertexBuffer = (float[])translator.GetObject(L, 2, typeof(float[])); + Spine.SkeletonClipping _clipper = (Spine.SkeletonClipping)translator.GetObject(L, 3, typeof(Spine.SkeletonClipping)); + + gen_to_be_invoked.GetBounds( out _x, out _y, out _width, out _height, ref _vertexBuffer, _clipper ); + LuaAPI.lua_pushnumber(L, _x); + + LuaAPI.lua_pushnumber(L, _y); + + LuaAPI.lua_pushnumber(L, _width); + + LuaAPI.lua_pushnumber(L, _height); + + translator.Push(L, _vertexBuffer); + + + + + return 5; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + float _x; + float _y; + float _width; + float _height; + float[] _vertexBuffer = (float[])translator.GetObject(L, 2, typeof(float[])); + + gen_to_be_invoked.GetBounds( out _x, out _y, out _width, out _height, ref _vertexBuffer ); + LuaAPI.lua_pushnumber(L, _x); + + LuaAPI.lua_pushnumber(L, _y); + + LuaAPI.lua_pushnumber(L, _width); + + LuaAPI.lua_pushnumber(L, _height); + + translator.Push(L, _vertexBuffer); + + + + + return 5; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to Spine.Skeleton.GetBounds!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)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_Data(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Data); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Bones(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Bones); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UpdateCacheList(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.UpdateCacheList); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Slots(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Slots); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DrawOrder(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.DrawOrder); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IkConstraints(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.IkConstraints); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PathConstraints(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.PathConstraints); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PhysicsConstraints(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.PhysicsConstraints); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_TransformConstraints(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.TransformConstraints); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Skin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Skin); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_R(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.R); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_G(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.G); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_B(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.B); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_A(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.A); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_X(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.X); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Y(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.Y); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ScaleX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.ScaleX); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ScaleY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.ScaleY); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Time(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.Time); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_RootBone(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.RootBone); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Skin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Skin = (Spine.Skin)translator.GetObject(L, 2, typeof(Spine.Skin)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_R(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.R = (float)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_G(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.G = (float)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_B(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.B = (float)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_A(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.A = (float)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_X(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.X = (float)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_Y(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Y = (float)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_ScaleX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ScaleX = (float)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_ScaleY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ScaleY = (float)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_Time(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Skeleton gen_to_be_invoked = (Spine.Skeleton)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Time = (float)LuaAPI.lua_tonumber(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/Spine_SlotWrap.cs b/Assets/XLua/Gen/Spine_SlotWrap.cs new file mode 100644 index 000000000..51b94b7a1 --- /dev/null +++ b/Assets/XLua/Gen/Spine_SlotWrap.cs @@ -0,0 +1,595 @@ +#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 SpineSlotWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(Spine.Slot); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 14, 11); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClampColor", _m_ClampColor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClampSecondColor", _m_ClampSecondColor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetToSetupPose", _m_SetToSetupPose); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Data", _g_get_Data); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Bone", _g_get_Bone); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Skeleton", _g_get_Skeleton); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "R", _g_get_R); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "G", _g_get_G); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "B", _g_get_B); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "A", _g_get_A); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "R2", _g_get_R2); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "G2", _g_get_G2); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "B2", _g_get_B2); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "HasSecondColor", _g_get_HasSecondColor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Attachment", _g_get_Attachment); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "SequenceIndex", _g_get_SequenceIndex); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Deform", _g_get_Deform); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "R", _s_set_R); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "G", _s_set_G); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "B", _s_set_B); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "A", _s_set_A); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "R2", _s_set_R2); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "G2", _s_set_G2); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "B2", _s_set_B2); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "HasSecondColor", _s_set_HasSecondColor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Attachment", _s_set_Attachment); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "SequenceIndex", _s_set_SequenceIndex); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Deform", _s_set_Deform); + + + 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 && translator.Assignable(L, 2) && translator.Assignable(L, 3)) + { + Spine.SlotData _data = (Spine.SlotData)translator.GetObject(L, 2, typeof(Spine.SlotData)); + Spine.Bone _bone = (Spine.Bone)translator.GetObject(L, 3, typeof(Spine.Bone)); + + var gen_ret = new Spine.Slot(_data, _bone); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 3 && translator.Assignable(L, 2) && translator.Assignable(L, 3)) + { + Spine.Slot _slot = (Spine.Slot)translator.GetObject(L, 2, typeof(Spine.Slot)); + Spine.Bone _bone = (Spine.Bone)translator.GetObject(L, 3, typeof(Spine.Bone)); + + var gen_ret = new Spine.Slot(_slot, _bone); + 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 Spine.Slot constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClampColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Slot gen_to_be_invoked = (Spine.Slot)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClampColor( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClampSecondColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Slot gen_to_be_invoked = (Spine.Slot)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClampSecondColor( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetToSetupPose(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Slot gen_to_be_invoked = (Spine.Slot)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetToSetupPose( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Slot gen_to_be_invoked = (Spine.Slot)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_Data(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Slot gen_to_be_invoked = (Spine.Slot)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Data); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Bone(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Slot gen_to_be_invoked = (Spine.Slot)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Bone); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Skeleton(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Slot gen_to_be_invoked = (Spine.Slot)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Skeleton); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_R(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Slot gen_to_be_invoked = (Spine.Slot)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.R); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_G(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Slot gen_to_be_invoked = (Spine.Slot)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.G); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_B(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Slot gen_to_be_invoked = (Spine.Slot)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.B); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_A(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Slot gen_to_be_invoked = (Spine.Slot)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.A); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_R2(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Slot gen_to_be_invoked = (Spine.Slot)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.R2); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_G2(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Slot gen_to_be_invoked = (Spine.Slot)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.G2); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_B2(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Slot gen_to_be_invoked = (Spine.Slot)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.B2); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_HasSecondColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Slot gen_to_be_invoked = (Spine.Slot)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.HasSecondColor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Attachment(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Slot gen_to_be_invoked = (Spine.Slot)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Attachment); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_SequenceIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Slot gen_to_be_invoked = (Spine.Slot)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.SequenceIndex); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Deform(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Slot gen_to_be_invoked = (Spine.Slot)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Deform); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_R(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Slot gen_to_be_invoked = (Spine.Slot)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.R = (float)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_G(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Slot gen_to_be_invoked = (Spine.Slot)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.G = (float)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_B(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Slot gen_to_be_invoked = (Spine.Slot)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.B = (float)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_A(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Slot gen_to_be_invoked = (Spine.Slot)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.A = (float)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_R2(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Slot gen_to_be_invoked = (Spine.Slot)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.R2 = (float)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_G2(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Slot gen_to_be_invoked = (Spine.Slot)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.G2 = (float)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_B2(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Slot gen_to_be_invoked = (Spine.Slot)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.B2 = (float)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_HasSecondColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Slot gen_to_be_invoked = (Spine.Slot)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.HasSecondColor = 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_Attachment(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Slot gen_to_be_invoked = (Spine.Slot)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Attachment = (Spine.Attachment)translator.GetObject(L, 2, typeof(Spine.Attachment)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_SequenceIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Slot gen_to_be_invoked = (Spine.Slot)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.SequenceIndex = 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_Deform(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Slot gen_to_be_invoked = (Spine.Slot)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Deform = (Spine.ExposedList)translator.GetObject(L, 2, typeof(Spine.ExposedList)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/Spine_TrackEntryWrap.cs b/Assets/XLua/Gen/Spine_TrackEntryWrap.cs new file mode 100644 index 000000000..1a75979e7 --- /dev/null +++ b/Assets/XLua/Gen/Spine_TrackEntryWrap.cs @@ -0,0 +1,1222 @@ +#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 SpineTrackEntryWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(Spine.TrackEntry); + Utils.BeginObjectRegister(type, L, translator, 0, 11, 32, 19); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Reset", _m_Reset); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMixDuration", _m_SetMixDuration); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetRotationDirections", _m_ResetRotationDirections); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AllowImmediateQueue", _m_AllowImmediateQueue); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Start", _e_Start); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Interrupt", _e_Interrupt); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "End", _e_End); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Dispose", _e_Dispose); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Complete", _e_Complete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Event", _e_Event); + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "TrackIndex", _g_get_TrackIndex); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Animation", _g_get_Animation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Loop", _g_get_Loop); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Delay", _g_get_Delay); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "TrackTime", _g_get_TrackTime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "TrackEnd", _g_get_TrackEnd); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "TrackComplete", _g_get_TrackComplete); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AnimationStart", _g_get_AnimationStart); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AnimationEnd", _g_get_AnimationEnd); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AnimationLast", _g_get_AnimationLast); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AnimationTime", _g_get_AnimationTime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "TimeScale", _g_get_TimeScale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Alpha", _g_get_Alpha); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "InterruptAlpha", _g_get_InterruptAlpha); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "EventThreshold", _g_get_EventThreshold); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AlphaAttachmentThreshold", _g_get_AlphaAttachmentThreshold); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "MixAttachmentThreshold", _g_get_MixAttachmentThreshold); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "MixDrawOrderThreshold", _g_get_MixDrawOrderThreshold); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Next", _g_get_Next); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Previous", _g_get_Previous); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "WasApplied", _g_get_WasApplied); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsNextReady", _g_get_IsNextReady); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsComplete", _g_get_IsComplete); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "MixTime", _g_get_MixTime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "MixDuration", _g_get_MixDuration); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "MixBlend", _g_get_MixBlend); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "MixingFrom", _g_get_MixingFrom); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "MixingTo", _g_get_MixingTo); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "HoldPrevious", _g_get_HoldPrevious); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Reverse", _g_get_Reverse); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ShortestRotation", _g_get_ShortestRotation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsEmptyAnimation", _g_get_IsEmptyAnimation); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Loop", _s_set_Loop); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Delay", _s_set_Delay); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "TrackTime", _s_set_TrackTime); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "TrackEnd", _s_set_TrackEnd); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "AnimationStart", _s_set_AnimationStart); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "AnimationEnd", _s_set_AnimationEnd); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "AnimationLast", _s_set_AnimationLast); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "TimeScale", _s_set_TimeScale); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Alpha", _s_set_Alpha); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "EventThreshold", _s_set_EventThreshold); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "AlphaAttachmentThreshold", _s_set_AlphaAttachmentThreshold); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "MixAttachmentThreshold", _s_set_MixAttachmentThreshold); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "MixDrawOrderThreshold", _s_set_MixDrawOrderThreshold); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "MixTime", _s_set_MixTime); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "MixDuration", _s_set_MixDuration); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "MixBlend", _s_set_MixBlend); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "HoldPrevious", _s_set_HoldPrevious); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Reverse", _s_set_Reverse); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ShortestRotation", _s_set_ShortestRotation); + + + 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 Spine.TrackEntry(); + 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 Spine.TrackEntry constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Reset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Reset( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMixDuration(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + + + + { + float _mixDuration = (float)LuaAPI.lua_tonumber(L, 2); + float _delay = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetMixDuration( _mixDuration, _delay ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetRotationDirections(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ResetRotationDirections( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)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 _m_AllowImmediateQueue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.AllowImmediateQueue( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_TrackIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.TrackIndex); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Animation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Animation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Loop(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.Loop); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Delay(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.Delay); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_TrackTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.TrackTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_TrackEnd(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.TrackEnd); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_TrackComplete(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.TrackComplete); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AnimationStart(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.AnimationStart); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AnimationEnd(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.AnimationEnd); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AnimationLast(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.AnimationLast); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AnimationTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.AnimationTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_TimeScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.TimeScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Alpha(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.Alpha); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_InterruptAlpha(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.InterruptAlpha); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_EventThreshold(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.EventThreshold); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AlphaAttachmentThreshold(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.AlphaAttachmentThreshold); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_MixAttachmentThreshold(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.MixAttachmentThreshold); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_MixDrawOrderThreshold(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.MixDrawOrderThreshold); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Next(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Next); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Previous(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Previous); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_WasApplied(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.WasApplied); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsNextReady(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsNextReady); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsComplete(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsComplete); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_MixTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.MixTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_MixDuration(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.MixDuration); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_MixBlend(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.MixBlend); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_MixingFrom(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.MixingFrom); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_MixingTo(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.MixingTo); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_HoldPrevious(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.HoldPrevious); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Reverse(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.Reverse); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ShortestRotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.ShortestRotation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsEmptyAnimation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsEmptyAnimation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Loop(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Loop = 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_Delay(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Delay = (float)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_TrackTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.TrackTime = (float)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_TrackEnd(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.TrackEnd = (float)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_AnimationStart(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.AnimationStart = (float)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_AnimationEnd(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.AnimationEnd = (float)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_AnimationLast(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.AnimationLast = (float)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_TimeScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.TimeScale = (float)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_Alpha(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Alpha = (float)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_EventThreshold(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.EventThreshold = (float)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_AlphaAttachmentThreshold(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.AlphaAttachmentThreshold = (float)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_MixAttachmentThreshold(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.MixAttachmentThreshold = (float)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_MixDrawOrderThreshold(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.MixDrawOrderThreshold = (float)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_MixTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.MixTime = (float)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_MixDuration(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.MixDuration = (float)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_MixBlend(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + Spine.MixBlend gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.MixBlend = 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_HoldPrevious(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.HoldPrevious = 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_Reverse(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Reverse = 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_ShortestRotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ShortestRotation = 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 _e_Start(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + Spine.AnimationState.TrackEntryDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.AnimationState.TrackEntryDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.Start += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.Start -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.TrackEntry.Start!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_Interrupt(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + Spine.AnimationState.TrackEntryDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.AnimationState.TrackEntryDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.Interrupt += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.Interrupt -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.TrackEntry.Interrupt!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_End(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + Spine.AnimationState.TrackEntryDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.AnimationState.TrackEntryDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.End += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.End -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.TrackEntry.End!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_Dispose(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + Spine.AnimationState.TrackEntryDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.AnimationState.TrackEntryDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.Dispose += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.Dispose -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.TrackEntry.Dispose!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_Complete(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + Spine.AnimationState.TrackEntryDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.AnimationState.TrackEntryDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.Complete += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.Complete -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.TrackEntry.Complete!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_Event(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.TrackEntry gen_to_be_invoked = (Spine.TrackEntry)translator.FastGetCSObj(L, 1); + Spine.AnimationState.TrackEntryEventDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.AnimationState.TrackEntryEventDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.Event += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.Event -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.TrackEntry.Event!"); + return 0; + } + + + + } +} diff --git a/Assets/XLua/Gen/Spine_Unity_BoneFollowerGraphicWrap.cs b/Assets/XLua/Gen/Spine_Unity_BoneFollowerGraphicWrap.cs new file mode 100644 index 000000000..79bb837dc --- /dev/null +++ b/Assets/XLua/Gen/Spine_Unity_BoneFollowerGraphicWrap.cs @@ -0,0 +1,602 @@ +#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 SpineUnityBoneFollowerGraphicWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(Spine.Unity.BoneFollowerGraphic); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 13, 13); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetBone", _m_SetBone); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Awake", _m_Awake); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Initialize", _m_Initialize); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LateUpdate", _m_LateUpdate); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "SkeletonGraphic", _g_get_SkeletonGraphic); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "skeletonGraphic", _g_get_skeletonGraphic); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "initializeOnAwake", _g_get_initializeOnAwake); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "boneName", _g_get_boneName); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "followBoneRotation", _g_get_followBoneRotation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "followSkeletonFlip", _g_get_followSkeletonFlip); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "followLocalScale", _g_get_followLocalScale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "followParentWorldScale", _g_get_followParentWorldScale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "followXYPosition", _g_get_followXYPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "followZPosition", _g_get_followZPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "maintainedAxisOrientation", _g_get_maintainedAxisOrientation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bone", _g_get_bone); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "valid", _g_get_valid); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "SkeletonGraphic", _s_set_SkeletonGraphic); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "skeletonGraphic", _s_set_skeletonGraphic); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "initializeOnAwake", _s_set_initializeOnAwake); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "boneName", _s_set_boneName); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "followBoneRotation", _s_set_followBoneRotation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "followSkeletonFlip", _s_set_followSkeletonFlip); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "followLocalScale", _s_set_followLocalScale); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "followParentWorldScale", _s_set_followParentWorldScale); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "followXYPosition", _s_set_followXYPosition); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "followZPosition", _s_set_followZPosition); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "maintainedAxisOrientation", _s_set_maintainedAxisOrientation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "bone", _s_set_bone); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "valid", _s_set_valid); + + + 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 Spine.Unity.BoneFollowerGraphic(); + 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 Spine.Unity.BoneFollowerGraphic constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetBone(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.SetBone( _name ); + 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_Awake(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Awake( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Initialize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Initialize( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LateUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.LateUpdate( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_SkeletonGraphic(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.SkeletonGraphic); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_skeletonGraphic(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.skeletonGraphic); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_initializeOnAwake(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.initializeOnAwake); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_boneName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.boneName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_followBoneRotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.followBoneRotation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_followSkeletonFlip(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.followSkeletonFlip); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_followLocalScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.followLocalScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_followParentWorldScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.followParentWorldScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_followXYPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.followXYPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_followZPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.followZPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maintainedAxisOrientation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + translator.PushSpineUnityBoneFollowerAxisOrientation(L, gen_to_be_invoked.maintainedAxisOrientation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bone(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.bone); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_valid(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.valid); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_SkeletonGraphic(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.SkeletonGraphic = (Spine.Unity.SkeletonGraphic)translator.GetObject(L, 2, typeof(Spine.Unity.SkeletonGraphic)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_skeletonGraphic(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.skeletonGraphic = (Spine.Unity.SkeletonGraphic)translator.GetObject(L, 2, typeof(Spine.Unity.SkeletonGraphic)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_initializeOnAwake(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.initializeOnAwake = 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_boneName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.boneName = 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_followBoneRotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.followBoneRotation = 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_followSkeletonFlip(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.followSkeletonFlip = 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_followLocalScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.followLocalScale = 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_followParentWorldScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.followParentWorldScale = 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_followXYPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.followXYPosition = 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_followZPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.followZPosition = 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_maintainedAxisOrientation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + Spine.Unity.BoneFollower.AxisOrientation gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.maintainedAxisOrientation = 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_bone(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.bone = (Spine.Bone)translator.GetObject(L, 2, typeof(Spine.Bone)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_valid(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollowerGraphic gen_to_be_invoked = (Spine.Unity.BoneFollowerGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.valid = LuaAPI.lua_toboolean(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/Spine_Unity_BoneFollowerWrap.cs b/Assets/XLua/Gen/Spine_Unity_BoneFollowerWrap.cs new file mode 100644 index 000000000..31435a694 --- /dev/null +++ b/Assets/XLua/Gen/Spine_Unity_BoneFollowerWrap.cs @@ -0,0 +1,631 @@ +#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 SpineUnityBoneFollowerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(Spine.Unity.BoneFollower); + Utils.BeginObjectRegister(type, L, translator, 0, 5, 13, 13); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetBone", _m_SetBone); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Awake", _m_Awake); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HandleRebuildRenderer", _m_HandleRebuildRenderer); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Initialize", _m_Initialize); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LateUpdate", _m_LateUpdate); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "SkeletonRenderer", _g_get_SkeletonRenderer); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "skeletonRenderer", _g_get_skeletonRenderer); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "boneName", _g_get_boneName); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "followXYPosition", _g_get_followXYPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "followZPosition", _g_get_followZPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "followBoneRotation", _g_get_followBoneRotation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "followSkeletonFlip", _g_get_followSkeletonFlip); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "followLocalScale", _g_get_followLocalScale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "followParentWorldScale", _g_get_followParentWorldScale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "maintainedAxisOrientation", _g_get_maintainedAxisOrientation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "initializeOnAwake", _g_get_initializeOnAwake); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "valid", _g_get_valid); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bone", _g_get_bone); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "SkeletonRenderer", _s_set_SkeletonRenderer); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "skeletonRenderer", _s_set_skeletonRenderer); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "boneName", _s_set_boneName); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "followXYPosition", _s_set_followXYPosition); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "followZPosition", _s_set_followZPosition); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "followBoneRotation", _s_set_followBoneRotation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "followSkeletonFlip", _s_set_followSkeletonFlip); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "followLocalScale", _s_set_followLocalScale); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "followParentWorldScale", _s_set_followParentWorldScale); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "maintainedAxisOrientation", _s_set_maintainedAxisOrientation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "initializeOnAwake", _s_set_initializeOnAwake); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "valid", _s_set_valid); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "bone", _s_set_bone); + + + 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 Spine.Unity.BoneFollower(); + 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 Spine.Unity.BoneFollower constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetBone(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.SetBone( _name ); + 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_Awake(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Awake( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HandleRebuildRenderer(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + + + + { + Spine.Unity.SkeletonRenderer _skeletonRenderer = (Spine.Unity.SkeletonRenderer)translator.GetObject(L, 2, typeof(Spine.Unity.SkeletonRenderer)); + + gen_to_be_invoked.HandleRebuildRenderer( _skeletonRenderer ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Initialize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Initialize( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LateUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.LateUpdate( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_SkeletonRenderer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.SkeletonRenderer); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_skeletonRenderer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.skeletonRenderer); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_boneName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.boneName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_followXYPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.followXYPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_followZPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.followZPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_followBoneRotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.followBoneRotation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_followSkeletonFlip(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.followSkeletonFlip); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_followLocalScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.followLocalScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_followParentWorldScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.followParentWorldScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maintainedAxisOrientation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + translator.PushSpineUnityBoneFollowerAxisOrientation(L, gen_to_be_invoked.maintainedAxisOrientation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_initializeOnAwake(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.initializeOnAwake); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_valid(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.valid); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bone(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.bone); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_SkeletonRenderer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.SkeletonRenderer = (Spine.Unity.SkeletonRenderer)translator.GetObject(L, 2, typeof(Spine.Unity.SkeletonRenderer)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_skeletonRenderer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.skeletonRenderer = (Spine.Unity.SkeletonRenderer)translator.GetObject(L, 2, typeof(Spine.Unity.SkeletonRenderer)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_boneName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.boneName = 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_followXYPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.followXYPosition = 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_followZPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.followZPosition = 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_followBoneRotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.followBoneRotation = 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_followSkeletonFlip(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.followSkeletonFlip = 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_followLocalScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.followLocalScale = 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_followParentWorldScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.followParentWorldScale = 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_maintainedAxisOrientation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + Spine.Unity.BoneFollower.AxisOrientation gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.maintainedAxisOrientation = 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_initializeOnAwake(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.initializeOnAwake = 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_valid(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.valid = 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_bone(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.BoneFollower gen_to_be_invoked = (Spine.Unity.BoneFollower)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.bone = (Spine.Bone)translator.GetObject(L, 2, typeof(Spine.Bone)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/Spine_Unity_MeshGeneratorWrap.cs b/Assets/XLua/Gen/Spine_Unity_MeshGeneratorWrap.cs new file mode 100644 index 000000000..47ce458d9 --- /dev/null +++ b/Assets/XLua/Gen/Spine_Unity_MeshGeneratorWrap.cs @@ -0,0 +1,804 @@ +#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 SpineUnityMeshGeneratorWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(Spine.Unity.MeshGenerator); + Utils.BeginObjectRegister(type, L, translator, 0, 13, 6, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SubmeshIndexCount", _m_SubmeshIndexCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Begin", _m_Begin); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddSubmesh", _m_AddSubmesh); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "BuildMesh", _m_BuildMesh); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "BuildMeshWithArrays", _m_BuildMeshWithArrays); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ScaleVertexData", _m_ScaleVertexData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ScaleAndOffsetVertexData", _m_ScaleAndOffsetVertexData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetMeshBounds", _m_GetMeshBounds); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FillVertexData", _m_FillVertexData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FillLateVertexData", _m_FillLateVertexData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FillTriangles", _m_FillTriangles); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "EnsureVertexCapacity", _m_EnsureVertexCapacity); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TrimExcess", _m_TrimExcess); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "UV2", _g_get_UV2); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "UV3", _g_get_UV3); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "VertexCount", _g_get_VertexCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Buffers", _g_get_Buffers); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "SkeletonClipping", _g_get_SkeletonClipping); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "settings", _g_get_settings); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "settings", _s_set_settings); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 6, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GenerateSingleSubmeshInstruction", _m_GenerateSingleSubmeshInstruction_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RequiresMultipleSubmeshesByDrawOrder", _m_RequiresMultipleSubmeshesByDrawOrder_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GenerateSkeletonRendererInstruction", _m_GenerateSkeletonRendererInstruction_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "TryReplaceMaterials", _m_TryReplaceMaterials_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FillMeshLocal", _m_FillMeshLocal_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 Spine.Unity.MeshGenerator(); + 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 Spine.Unity.MeshGenerator constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SubmeshIndexCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.MeshGenerator gen_to_be_invoked = (Spine.Unity.MeshGenerator)translator.FastGetCSObj(L, 1); + + + + { + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.SubmeshIndexCount( _submeshIndex ); + 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_GenerateSingleSubmeshInstruction_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + Spine.Unity.SkeletonRendererInstruction _instructionOutput = (Spine.Unity.SkeletonRendererInstruction)translator.GetObject(L, 1, typeof(Spine.Unity.SkeletonRendererInstruction)); + Spine.Skeleton _skeleton = (Spine.Skeleton)translator.GetObject(L, 2, typeof(Spine.Skeleton)); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + + Spine.Unity.MeshGenerator.GenerateSingleSubmeshInstruction( _instructionOutput, _skeleton, _material ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RequiresMultipleSubmeshesByDrawOrder_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + Spine.Skeleton _skeleton = (Spine.Skeleton)translator.GetObject(L, 1, typeof(Spine.Skeleton)); + + var gen_ret = Spine.Unity.MeshGenerator.RequiresMultipleSubmeshesByDrawOrder( _skeleton ); + 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_GenerateSkeletonRendererInstruction_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 6&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable>(L, 3)&& translator.Assignable>(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)) + { + Spine.Unity.SkeletonRendererInstruction _instructionOutput = (Spine.Unity.SkeletonRendererInstruction)translator.GetObject(L, 1, typeof(Spine.Unity.SkeletonRendererInstruction)); + Spine.Skeleton _skeleton = (Spine.Skeleton)translator.GetObject(L, 2, typeof(Spine.Skeleton)); + System.Collections.Generic.Dictionary _customSlotMaterials = (System.Collections.Generic.Dictionary)translator.GetObject(L, 3, typeof(System.Collections.Generic.Dictionary)); + System.Collections.Generic.List _separatorSlots = (System.Collections.Generic.List)translator.GetObject(L, 4, typeof(System.Collections.Generic.List)); + bool _generateMeshOverride = LuaAPI.lua_toboolean(L, 5); + bool _immutableTriangles = LuaAPI.lua_toboolean(L, 6); + + Spine.Unity.MeshGenerator.GenerateSkeletonRendererInstruction( _instructionOutput, _skeleton, _customSlotMaterials, _separatorSlots, _generateMeshOverride, _immutableTriangles ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable>(L, 3)&& translator.Assignable>(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)) + { + Spine.Unity.SkeletonRendererInstruction _instructionOutput = (Spine.Unity.SkeletonRendererInstruction)translator.GetObject(L, 1, typeof(Spine.Unity.SkeletonRendererInstruction)); + Spine.Skeleton _skeleton = (Spine.Skeleton)translator.GetObject(L, 2, typeof(Spine.Skeleton)); + System.Collections.Generic.Dictionary _customSlotMaterials = (System.Collections.Generic.Dictionary)translator.GetObject(L, 3, typeof(System.Collections.Generic.Dictionary)); + System.Collections.Generic.List _separatorSlots = (System.Collections.Generic.List)translator.GetObject(L, 4, typeof(System.Collections.Generic.List)); + bool _generateMeshOverride = LuaAPI.lua_toboolean(L, 5); + + Spine.Unity.MeshGenerator.GenerateSkeletonRendererInstruction( _instructionOutput, _skeleton, _customSlotMaterials, _separatorSlots, _generateMeshOverride ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.MeshGenerator.GenerateSkeletonRendererInstruction!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TryReplaceMaterials_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + Spine.ExposedList _workingSubmeshInstructions = (Spine.ExposedList)translator.GetObject(L, 1, typeof(Spine.ExposedList)); + System.Collections.Generic.Dictionary _customMaterialOverride = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + + Spine.Unity.MeshGenerator.TryReplaceMaterials( _workingSubmeshInstructions, _customMaterialOverride ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Begin(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.MeshGenerator gen_to_be_invoked = (Spine.Unity.MeshGenerator)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Begin( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddSubmesh(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.MeshGenerator gen_to_be_invoked = (Spine.Unity.MeshGenerator)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + Spine.Unity.SubmeshInstruction _instruction;translator.Get(L, 2, out _instruction); + bool _updateTriangles = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.AddSubmesh( _instruction, _updateTriangles ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + Spine.Unity.SubmeshInstruction _instruction;translator.Get(L, 2, out _instruction); + + gen_to_be_invoked.AddSubmesh( _instruction ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.MeshGenerator.AddSubmesh!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_BuildMesh(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.MeshGenerator gen_to_be_invoked = (Spine.Unity.MeshGenerator)translator.FastGetCSObj(L, 1); + + + + { + Spine.Unity.SkeletonRendererInstruction _instruction = (Spine.Unity.SkeletonRendererInstruction)translator.GetObject(L, 2, typeof(Spine.Unity.SkeletonRendererInstruction)); + bool _updateTriangles = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.BuildMesh( _instruction, _updateTriangles ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_BuildMeshWithArrays(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.MeshGenerator gen_to_be_invoked = (Spine.Unity.MeshGenerator)translator.FastGetCSObj(L, 1); + + + + { + Spine.Unity.SkeletonRendererInstruction _instruction = (Spine.Unity.SkeletonRendererInstruction)translator.GetObject(L, 2, typeof(Spine.Unity.SkeletonRendererInstruction)); + bool _updateTriangles = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.BuildMeshWithArrays( _instruction, _updateTriangles ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ScaleVertexData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.MeshGenerator gen_to_be_invoked = (Spine.Unity.MeshGenerator)translator.FastGetCSObj(L, 1); + + + + { + float _scale = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.ScaleVertexData( _scale ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ScaleAndOffsetVertexData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.MeshGenerator gen_to_be_invoked = (Spine.Unity.MeshGenerator)translator.FastGetCSObj(L, 1); + + + + { + float _scale = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector2 _offset2D;translator.Get(L, 3, out _offset2D); + + gen_to_be_invoked.ScaleAndOffsetVertexData( _scale, _offset2D ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetMeshBounds(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.MeshGenerator gen_to_be_invoked = (Spine.Unity.MeshGenerator)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetMeshBounds( ); + translator.PushUnityEngineBounds(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_FillVertexData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.MeshGenerator gen_to_be_invoked = (Spine.Unity.MeshGenerator)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + + gen_to_be_invoked.FillVertexData( _mesh ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FillLateVertexData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.MeshGenerator gen_to_be_invoked = (Spine.Unity.MeshGenerator)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + + gen_to_be_invoked.FillLateVertexData( _mesh ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FillTriangles(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.MeshGenerator gen_to_be_invoked = (Spine.Unity.MeshGenerator)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + + gen_to_be_invoked.FillTriangles( _mesh ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_EnsureVertexCapacity(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.MeshGenerator gen_to_be_invoked = (Spine.Unity.MeshGenerator)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)) + { + int _minimumVertexCount = LuaAPI.xlua_tointeger(L, 2); + bool _inlcudeTintBlack = LuaAPI.lua_toboolean(L, 3); + bool _includeTangents = LuaAPI.lua_toboolean(L, 4); + bool _includeNormals = LuaAPI.lua_toboolean(L, 5); + + gen_to_be_invoked.EnsureVertexCapacity( _minimumVertexCount, _inlcudeTintBlack, _includeTangents, _includeNormals ); + + + + return 0; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + int _minimumVertexCount = LuaAPI.xlua_tointeger(L, 2); + bool _inlcudeTintBlack = LuaAPI.lua_toboolean(L, 3); + bool _includeTangents = LuaAPI.lua_toboolean(L, 4); + + gen_to_be_invoked.EnsureVertexCapacity( _minimumVertexCount, _inlcudeTintBlack, _includeTangents ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + int _minimumVertexCount = LuaAPI.xlua_tointeger(L, 2); + bool _inlcudeTintBlack = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.EnsureVertexCapacity( _minimumVertexCount, _inlcudeTintBlack ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _minimumVertexCount = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.EnsureVertexCapacity( _minimumVertexCount ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.MeshGenerator.EnsureVertexCapacity!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TrimExcess(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.MeshGenerator gen_to_be_invoked = (Spine.Unity.MeshGenerator)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.TrimExcess( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FillMeshLocal_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + Spine.RegionAttachment _regionAttachment = (Spine.RegionAttachment)translator.GetObject(L, 2, typeof(Spine.RegionAttachment)); + + Spine.Unity.MeshGenerator.FillMeshLocal( _mesh, _regionAttachment ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + Spine.MeshAttachment _meshAttachment = (Spine.MeshAttachment)translator.GetObject(L, 2, typeof(Spine.MeshAttachment)); + Spine.SkeletonData _skeletonData = (Spine.SkeletonData)translator.GetObject(L, 3, typeof(Spine.SkeletonData)); + + Spine.Unity.MeshGenerator.FillMeshLocal( _mesh, _meshAttachment, _skeletonData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.MeshGenerator.FillMeshLocal!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UV2(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.MeshGenerator gen_to_be_invoked = (Spine.Unity.MeshGenerator)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.UV2); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UV3(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.MeshGenerator gen_to_be_invoked = (Spine.Unity.MeshGenerator)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.UV3); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_VertexCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.MeshGenerator gen_to_be_invoked = (Spine.Unity.MeshGenerator)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.VertexCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Buffers(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.MeshGenerator gen_to_be_invoked = (Spine.Unity.MeshGenerator)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Buffers); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_SkeletonClipping(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.MeshGenerator gen_to_be_invoked = (Spine.Unity.MeshGenerator)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.SkeletonClipping); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_settings(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.MeshGenerator gen_to_be_invoked = (Spine.Unity.MeshGenerator)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.settings); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_settings(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.MeshGenerator gen_to_be_invoked = (Spine.Unity.MeshGenerator)translator.FastGetCSObj(L, 1); + Spine.Unity.MeshGenerator.Settings gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.settings = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/Spine_Unity_MeshGenerator_SettingsWrap.cs b/Assets/XLua/Gen/Spine_Unity_MeshGenerator_SettingsWrap.cs new file mode 100644 index 000000000..c26dc918c --- /dev/null +++ b/Assets/XLua/Gen/Spine_Unity_MeshGenerator_SettingsWrap.cs @@ -0,0 +1,359 @@ +#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 SpineUnityMeshGeneratorSettingsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(Spine.Unity.MeshGenerator.Settings); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 8, 8); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "useClipping", _g_get_useClipping); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "zSpacing", _g_get_zSpacing); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "tintBlack", _g_get_tintBlack); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "canvasGroupCompatible", _g_get_canvasGroupCompatible); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "pmaVertexColors", _g_get_pmaVertexColors); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "addNormals", _g_get_addNormals); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "calculateTangents", _g_get_calculateTangents); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "immutableTriangles", _g_get_immutableTriangles); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "useClipping", _s_set_useClipping); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "zSpacing", _s_set_zSpacing); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "tintBlack", _s_set_tintBlack); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "canvasGroupCompatible", _s_set_canvasGroupCompatible); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "pmaVertexColors", _s_set_pmaVertexColors); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "addNormals", _s_set_addNormals); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "calculateTangents", _s_set_calculateTangents); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "immutableTriangles", _s_set_immutableTriangles); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 1, 0); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "Default", _g_get_Default); + + + + 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) + { + translator.Push(L, default(Spine.Unity.MeshGenerator.Settings)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.MeshGenerator.Settings constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Default(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, Spine.Unity.MeshGenerator.Settings.Default); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_useClipping(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.MeshGenerator.Settings gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.useClipping); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_zSpacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.MeshGenerator.Settings gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.zSpacing); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_tintBlack(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.MeshGenerator.Settings gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.tintBlack); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_canvasGroupCompatible(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.MeshGenerator.Settings gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.canvasGroupCompatible); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_pmaVertexColors(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.MeshGenerator.Settings gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.pmaVertexColors); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_addNormals(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.MeshGenerator.Settings gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.addNormals); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_calculateTangents(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.MeshGenerator.Settings gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.calculateTangents); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_immutableTriangles(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.MeshGenerator.Settings gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.immutableTriangles); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_useClipping(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.MeshGenerator.Settings gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.useClipping = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_zSpacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.MeshGenerator.Settings gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.zSpacing = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_tintBlack(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.MeshGenerator.Settings gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.tintBlack = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_canvasGroupCompatible(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.MeshGenerator.Settings gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.canvasGroupCompatible = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_pmaVertexColors(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.MeshGenerator.Settings gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.pmaVertexColors = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_addNormals(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.MeshGenerator.Settings gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.addNormals = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_calculateTangents(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.MeshGenerator.Settings gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.calculateTangents = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_immutableTriangles(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.MeshGenerator.Settings gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.immutableTriangles = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/Spine_Unity_SkeletonAnimationWrap.cs b/Assets/XLua/Gen/Spine_Unity_SkeletonAnimationWrap.cs new file mode 100644 index 000000000..047231081 --- /dev/null +++ b/Assets/XLua/Gen/Spine_Unity_SkeletonAnimationWrap.cs @@ -0,0 +1,764 @@ +#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 SpineUnitySkeletonAnimationWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(Spine.Unity.SkeletonAnimation); + Utils.BeginObjectRegister(type, L, translator, 0, 12, 7, 6); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearState", _m_ClearState); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Initialize", _m_Initialize); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Update", _m_Update); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ApplyAnimation", _m_ApplyAnimation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AfterAnimationApplied", _m_AfterAnimationApplied); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LateUpdate", _m_LateUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBecameVisible", _m_OnBecameVisible); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnAnimationRebuild", _e_OnAnimationRebuild); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "BeforeApply", _e_BeforeApply); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateLocal", _e_UpdateLocal); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateWorld", _e_UpdateWorld); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateComplete", _e_UpdateComplete); + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AnimationState", _g_get_AnimationState); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "UpdateTiming", _g_get_UpdateTiming); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "UnscaledTime", _g_get_UnscaledTime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AnimationName", _g_get_AnimationName); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "state", _g_get_state); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "loop", _g_get_loop); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "timeScale", _g_get_timeScale); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "UpdateTiming", _s_set_UpdateTiming); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "UnscaledTime", _s_set_UnscaledTime); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "AnimationName", _s_set_AnimationName); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "state", _s_set_state); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "loop", _s_set_loop); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "timeScale", _s_set_timeScale); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 3, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "AddToGameObject", _m_AddToGameObject_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "NewSkeletonAnimationGameObject", _m_NewSkeletonAnimationGameObject_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 Spine.Unity.SkeletonAnimation(); + 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 Spine.Unity.SkeletonAnimation constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddToGameObject_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + UnityEngine.GameObject _gameObject = (UnityEngine.GameObject)translator.GetObject(L, 1, typeof(UnityEngine.GameObject)); + Spine.Unity.SkeletonDataAsset _skeletonDataAsset = (Spine.Unity.SkeletonDataAsset)translator.GetObject(L, 2, typeof(Spine.Unity.SkeletonDataAsset)); + bool _quiet = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = Spine.Unity.SkeletonAnimation.AddToGameObject( _gameObject, _skeletonDataAsset, _quiet ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.GameObject _gameObject = (UnityEngine.GameObject)translator.GetObject(L, 1, typeof(UnityEngine.GameObject)); + Spine.Unity.SkeletonDataAsset _skeletonDataAsset = (Spine.Unity.SkeletonDataAsset)translator.GetObject(L, 2, typeof(Spine.Unity.SkeletonDataAsset)); + + var gen_ret = Spine.Unity.SkeletonAnimation.AddToGameObject( _gameObject, _skeletonDataAsset ); + 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 Spine.Unity.SkeletonAnimation.AddToGameObject!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_NewSkeletonAnimationGameObject_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + Spine.Unity.SkeletonDataAsset _skeletonDataAsset = (Spine.Unity.SkeletonDataAsset)translator.GetObject(L, 1, typeof(Spine.Unity.SkeletonDataAsset)); + bool _quiet = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = Spine.Unity.SkeletonAnimation.NewSkeletonAnimationGameObject( _skeletonDataAsset, _quiet ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + Spine.Unity.SkeletonDataAsset _skeletonDataAsset = (Spine.Unity.SkeletonDataAsset)translator.GetObject(L, 1, typeof(Spine.Unity.SkeletonDataAsset)); + + var gen_ret = Spine.Unity.SkeletonAnimation.NewSkeletonAnimationGameObject( _skeletonDataAsset ); + 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 Spine.Unity.SkeletonAnimation.NewSkeletonAnimationGameObject!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearState(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonAnimation gen_to_be_invoked = (Spine.Unity.SkeletonAnimation)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearState( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Initialize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonAnimation gen_to_be_invoked = (Spine.Unity.SkeletonAnimation)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + bool _overwrite = LuaAPI.lua_toboolean(L, 2); + bool _quiet = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.Initialize( _overwrite, _quiet ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _overwrite = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.Initialize( _overwrite ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.SkeletonAnimation.Initialize!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Update(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonAnimation gen_to_be_invoked = (Spine.Unity.SkeletonAnimation)translator.FastGetCSObj(L, 1); + + + + { + float _deltaTime = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.Update( _deltaTime ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ApplyAnimation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonAnimation gen_to_be_invoked = (Spine.Unity.SkeletonAnimation)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ApplyAnimation( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AfterAnimationApplied(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonAnimation gen_to_be_invoked = (Spine.Unity.SkeletonAnimation)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.AfterAnimationApplied( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LateUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonAnimation gen_to_be_invoked = (Spine.Unity.SkeletonAnimation)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.LateUpdate( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnBecameVisible(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonAnimation gen_to_be_invoked = (Spine.Unity.SkeletonAnimation)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.OnBecameVisible( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AnimationState(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonAnimation gen_to_be_invoked = (Spine.Unity.SkeletonAnimation)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.AnimationState); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UpdateTiming(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonAnimation gen_to_be_invoked = (Spine.Unity.SkeletonAnimation)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.UpdateTiming); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UnscaledTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonAnimation gen_to_be_invoked = (Spine.Unity.SkeletonAnimation)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.UnscaledTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AnimationName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonAnimation gen_to_be_invoked = (Spine.Unity.SkeletonAnimation)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.AnimationName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_state(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonAnimation gen_to_be_invoked = (Spine.Unity.SkeletonAnimation)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.state); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_loop(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonAnimation gen_to_be_invoked = (Spine.Unity.SkeletonAnimation)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.loop); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_timeScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonAnimation gen_to_be_invoked = (Spine.Unity.SkeletonAnimation)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.timeScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_UpdateTiming(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonAnimation gen_to_be_invoked = (Spine.Unity.SkeletonAnimation)translator.FastGetCSObj(L, 1); + Spine.Unity.UpdateTiming gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.UpdateTiming = 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_UnscaledTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonAnimation gen_to_be_invoked = (Spine.Unity.SkeletonAnimation)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.UnscaledTime = 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_AnimationName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonAnimation gen_to_be_invoked = (Spine.Unity.SkeletonAnimation)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.AnimationName = 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_state(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonAnimation gen_to_be_invoked = (Spine.Unity.SkeletonAnimation)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.state = (Spine.AnimationState)translator.GetObject(L, 2, typeof(Spine.AnimationState)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_loop(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonAnimation gen_to_be_invoked = (Spine.Unity.SkeletonAnimation)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.loop = 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_timeScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonAnimation gen_to_be_invoked = (Spine.Unity.SkeletonAnimation)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.timeScale = (float)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 _e_OnAnimationRebuild(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.Unity.SkeletonAnimation gen_to_be_invoked = (Spine.Unity.SkeletonAnimation)translator.FastGetCSObj(L, 1); + Spine.Unity.ISkeletonAnimationDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.Unity.ISkeletonAnimationDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnAnimationRebuild += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnAnimationRebuild -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.SkeletonAnimation.OnAnimationRebuild!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_BeforeApply(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.Unity.SkeletonAnimation gen_to_be_invoked = (Spine.Unity.SkeletonAnimation)translator.FastGetCSObj(L, 1); + Spine.Unity.UpdateBonesDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.Unity.UpdateBonesDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.BeforeApply += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.BeforeApply -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.SkeletonAnimation.BeforeApply!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_UpdateLocal(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.Unity.SkeletonAnimation gen_to_be_invoked = (Spine.Unity.SkeletonAnimation)translator.FastGetCSObj(L, 1); + Spine.Unity.UpdateBonesDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.Unity.UpdateBonesDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.UpdateLocal += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.UpdateLocal -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.SkeletonAnimation.UpdateLocal!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_UpdateWorld(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.Unity.SkeletonAnimation gen_to_be_invoked = (Spine.Unity.SkeletonAnimation)translator.FastGetCSObj(L, 1); + Spine.Unity.UpdateBonesDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.Unity.UpdateBonesDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.UpdateWorld += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.UpdateWorld -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.SkeletonAnimation.UpdateWorld!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_UpdateComplete(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.Unity.SkeletonAnimation gen_to_be_invoked = (Spine.Unity.SkeletonAnimation)translator.FastGetCSObj(L, 1); + Spine.Unity.UpdateBonesDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.Unity.UpdateBonesDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.UpdateComplete += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.UpdateComplete -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.SkeletonAnimation.UpdateComplete!"); + return 0; + } + + + + } +} diff --git a/Assets/XLua/Gen/Spine_Unity_SkeletonDataAssetWrap.cs b/Assets/XLua/Gen/Spine_Unity_SkeletonDataAssetWrap.cs new file mode 100644 index 000000000..a311d2280 --- /dev/null +++ b/Assets/XLua/Gen/Spine_Unity_SkeletonDataAssetWrap.cs @@ -0,0 +1,674 @@ +#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 SpineUnitySkeletonDataAssetWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(Spine.Unity.SkeletonDataAsset); + Utils.BeginObjectRegister(type, L, translator, 0, 5, 12, 11); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetupRuntimeBlendModeMaterials", _m_SetupRuntimeBlendModeMaterials); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAnimationStateData", _m_GetAnimationStateData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSkeletonData", _m_GetSkeletonData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FillStateData", _m_FillStateData); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsLoaded", _g_get_IsLoaded); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "atlasAssets", _g_get_atlasAssets); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "scale", _g_get_scale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "skeletonJSON", _g_get_skeletonJSON); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isUpgradingBlendModeMaterials", _g_get_isUpgradingBlendModeMaterials); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "blendModeMaterials", _g_get_blendModeMaterials); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "skeletonDataModifiers", _g_get_skeletonDataModifiers); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fromAnimation", _g_get_fromAnimation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "toAnimation", _g_get_toAnimation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "duration", _g_get_duration); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "defaultMix", _g_get_defaultMix); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "controller", _g_get_controller); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "atlasAssets", _s_set_atlasAssets); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "scale", _s_set_scale); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "skeletonJSON", _s_set_skeletonJSON); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "isUpgradingBlendModeMaterials", _s_set_isUpgradingBlendModeMaterials); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "blendModeMaterials", _s_set_blendModeMaterials); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "skeletonDataModifiers", _s_set_skeletonDataModifiers); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fromAnimation", _s_set_fromAnimation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "toAnimation", _s_set_toAnimation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "duration", _s_set_duration); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "defaultMix", _s_set_defaultMix); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "controller", _s_set_controller); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CreateRuntimeInstance", _m_CreateRuntimeInstance_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 Spine.Unity.SkeletonDataAsset(); + 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 Spine.Unity.SkeletonDataAsset constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CreateRuntimeInstance_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.TextAsset _skeletonDataFile = (UnityEngine.TextAsset)translator.GetObject(L, 1, typeof(UnityEngine.TextAsset)); + Spine.Unity.AtlasAssetBase _atlasAsset = (Spine.Unity.AtlasAssetBase)translator.GetObject(L, 2, typeof(Spine.Unity.AtlasAssetBase)); + bool _initialize = LuaAPI.lua_toboolean(L, 3); + float _scale = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = Spine.Unity.SkeletonDataAsset.CreateRuntimeInstance( _skeletonDataFile, _atlasAsset, _initialize, _scale ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + UnityEngine.TextAsset _skeletonDataFile = (UnityEngine.TextAsset)translator.GetObject(L, 1, typeof(UnityEngine.TextAsset)); + Spine.Unity.AtlasAssetBase _atlasAsset = (Spine.Unity.AtlasAssetBase)translator.GetObject(L, 2, typeof(Spine.Unity.AtlasAssetBase)); + bool _initialize = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = Spine.Unity.SkeletonDataAsset.CreateRuntimeInstance( _skeletonDataFile, _atlasAsset, _initialize ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.TextAsset _skeletonDataFile = (UnityEngine.TextAsset)translator.GetObject(L, 1, typeof(UnityEngine.TextAsset)); + Spine.Unity.AtlasAssetBase[] _atlasAssets = (Spine.Unity.AtlasAssetBase[])translator.GetObject(L, 2, typeof(Spine.Unity.AtlasAssetBase[])); + bool _initialize = LuaAPI.lua_toboolean(L, 3); + float _scale = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = Spine.Unity.SkeletonDataAsset.CreateRuntimeInstance( _skeletonDataFile, _atlasAssets, _initialize, _scale ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + UnityEngine.TextAsset _skeletonDataFile = (UnityEngine.TextAsset)translator.GetObject(L, 1, typeof(UnityEngine.TextAsset)); + Spine.Unity.AtlasAssetBase[] _atlasAssets = (Spine.Unity.AtlasAssetBase[])translator.GetObject(L, 2, typeof(Spine.Unity.AtlasAssetBase[])); + bool _initialize = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = Spine.Unity.SkeletonDataAsset.CreateRuntimeInstance( _skeletonDataFile, _atlasAssets, _initialize ); + 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 Spine.Unity.SkeletonDataAsset.CreateRuntimeInstance!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetupRuntimeBlendModeMaterials(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonDataAsset gen_to_be_invoked = (Spine.Unity.SkeletonDataAsset)translator.FastGetCSObj(L, 1); + + + + { + bool _applyAdditiveMaterial = LuaAPI.lua_toboolean(L, 2); + Spine.Unity.BlendModeMaterials.TemplateMaterials _templateMaterials = (Spine.Unity.BlendModeMaterials.TemplateMaterials)translator.GetObject(L, 3, typeof(Spine.Unity.BlendModeMaterials.TemplateMaterials)); + + gen_to_be_invoked.SetupRuntimeBlendModeMaterials( _applyAdditiveMaterial, _templateMaterials ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Clear(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonDataAsset gen_to_be_invoked = (Spine.Unity.SkeletonDataAsset)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Clear( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetAnimationStateData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonDataAsset gen_to_be_invoked = (Spine.Unity.SkeletonDataAsset)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetAnimationStateData( ); + 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_GetSkeletonData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonDataAsset gen_to_be_invoked = (Spine.Unity.SkeletonDataAsset)translator.FastGetCSObj(L, 1); + + + + { + bool _quiet = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.GetSkeletonData( _quiet ); + 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_FillStateData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonDataAsset gen_to_be_invoked = (Spine.Unity.SkeletonDataAsset)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _quiet = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.FillStateData( _quiet ); + + + + return 0; + } + if(gen_param_count == 1) + { + + gen_to_be_invoked.FillStateData( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.SkeletonDataAsset.FillStateData!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsLoaded(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonDataAsset gen_to_be_invoked = (Spine.Unity.SkeletonDataAsset)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsLoaded); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_atlasAssets(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonDataAsset gen_to_be_invoked = (Spine.Unity.SkeletonDataAsset)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.atlasAssets); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_scale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonDataAsset gen_to_be_invoked = (Spine.Unity.SkeletonDataAsset)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.scale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_skeletonJSON(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonDataAsset gen_to_be_invoked = (Spine.Unity.SkeletonDataAsset)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.skeletonJSON); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isUpgradingBlendModeMaterials(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonDataAsset gen_to_be_invoked = (Spine.Unity.SkeletonDataAsset)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isUpgradingBlendModeMaterials); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_blendModeMaterials(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonDataAsset gen_to_be_invoked = (Spine.Unity.SkeletonDataAsset)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.blendModeMaterials); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_skeletonDataModifiers(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonDataAsset gen_to_be_invoked = (Spine.Unity.SkeletonDataAsset)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.skeletonDataModifiers); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fromAnimation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonDataAsset gen_to_be_invoked = (Spine.Unity.SkeletonDataAsset)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.fromAnimation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_toAnimation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonDataAsset gen_to_be_invoked = (Spine.Unity.SkeletonDataAsset)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.toAnimation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_duration(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonDataAsset gen_to_be_invoked = (Spine.Unity.SkeletonDataAsset)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.duration); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_defaultMix(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonDataAsset gen_to_be_invoked = (Spine.Unity.SkeletonDataAsset)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.defaultMix); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_controller(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonDataAsset gen_to_be_invoked = (Spine.Unity.SkeletonDataAsset)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.controller); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_atlasAssets(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonDataAsset gen_to_be_invoked = (Spine.Unity.SkeletonDataAsset)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.atlasAssets = (Spine.Unity.AtlasAssetBase[])translator.GetObject(L, 2, typeof(Spine.Unity.AtlasAssetBase[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_scale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonDataAsset gen_to_be_invoked = (Spine.Unity.SkeletonDataAsset)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.scale = (float)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_skeletonJSON(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonDataAsset gen_to_be_invoked = (Spine.Unity.SkeletonDataAsset)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.skeletonJSON = (UnityEngine.TextAsset)translator.GetObject(L, 2, typeof(UnityEngine.TextAsset)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_isUpgradingBlendModeMaterials(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonDataAsset gen_to_be_invoked = (Spine.Unity.SkeletonDataAsset)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.isUpgradingBlendModeMaterials = 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_blendModeMaterials(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonDataAsset gen_to_be_invoked = (Spine.Unity.SkeletonDataAsset)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.blendModeMaterials = (Spine.Unity.BlendModeMaterials)translator.GetObject(L, 2, typeof(Spine.Unity.BlendModeMaterials)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_skeletonDataModifiers(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonDataAsset gen_to_be_invoked = (Spine.Unity.SkeletonDataAsset)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.skeletonDataModifiers = (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; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_fromAnimation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonDataAsset gen_to_be_invoked = (Spine.Unity.SkeletonDataAsset)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.fromAnimation = (string[])translator.GetObject(L, 2, typeof(string[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_toAnimation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonDataAsset gen_to_be_invoked = (Spine.Unity.SkeletonDataAsset)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.toAnimation = (string[])translator.GetObject(L, 2, typeof(string[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_duration(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonDataAsset gen_to_be_invoked = (Spine.Unity.SkeletonDataAsset)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.duration = (float[])translator.GetObject(L, 2, typeof(float[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_defaultMix(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonDataAsset gen_to_be_invoked = (Spine.Unity.SkeletonDataAsset)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.defaultMix = (float)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_controller(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonDataAsset gen_to_be_invoked = (Spine.Unity.SkeletonDataAsset)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.controller = (UnityEngine.RuntimeAnimatorController)translator.GetObject(L, 2, typeof(UnityEngine.RuntimeAnimatorController)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/Spine_Unity_SkeletonGraphicWrap.cs b/Assets/XLua/Gen/Spine_Unity_SkeletonGraphicWrap.cs new file mode 100644 index 000000000..32e761f81 --- /dev/null +++ b/Assets/XLua/Gen/Spine_Unity_SkeletonGraphicWrap.cs @@ -0,0 +1,2337 @@ +#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 SpineUnitySkeletonGraphicWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(Spine.Unity.SkeletonGraphic); + Utils.BeginObjectRegister(type, L, translator, 0, 33, 44, 28); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Rebuild", _m_Rebuild); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Update", _m_Update); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ApplyTransformMovementToPhysics", _m_ApplyTransformMovementToPhysics); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ApplyAnimation", _m_ApplyAnimation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AfterAnimationApplied", _m_AfterAnimationApplied); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LateUpdate", _m_LateUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBecameVisible", _m_OnBecameVisible); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBecameInvisible", _m_OnBecameInvisible); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ReapplySeparatorSlotNames", _m_ReapplySeparatorSlotNames); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetLastPosition", _m_ResetLastPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetLastRotation", _m_ResetLastRotation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetLastPositionAndRotation", _m_ResetLastPositionAndRotation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetLastMesh", _m_GetLastMesh); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "MatchRectTransformWithBounds", _m_MatchRectTransformWithBounds); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TrimRenderers", _m_TrimRenderers); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Initialize", _m_Initialize); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PrepareInstructionsAndRenderers", _m_PrepareInstructionsAndRenderers); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateMesh", _m_UpdateMesh); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateMeshToInstructions", _m_UpdateMeshToInstructions); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasMultipleSubmeshInstructions", _m_HasMultipleSubmeshInstructions); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetScaledPivotOffset", _m_SetScaledPivotOffset); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AssignMeshOverrideSingleRenderer", _e_AssignMeshOverrideSingleRenderer); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AssignMeshOverrideMultipleRenderers", _e_AssignMeshOverrideMultipleRenderers); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRebuild", _e_OnRebuild); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnInstructionsPrepared", _e_OnInstructionsPrepared); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnMeshAndMaterialsUpdated", _e_OnMeshAndMaterialsUpdated); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnAnimationRebuild", _e_OnAnimationRebuild); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "BeforeApply", _e_BeforeApply); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateLocal", _e_UpdateLocal); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateWorld", _e_UpdateWorld); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateComplete", _e_UpdateComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPostProcessVertices", _e_OnPostProcessVertices); + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "SkeletonDataAsset", _g_get_SkeletonDataAsset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "color", _g_get_color); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "MeshScale", _g_get_MeshScale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "MeshOffset", _g_get_MeshOffset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "UpdateMode", _g_get_UpdateMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "SeparatorParts", _g_get_SeparatorParts); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "CustomTextureOverride", _g_get_CustomTextureOverride); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "CustomMaterialOverride", _g_get_CustomMaterialOverride); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "OverrideTexture", _g_get_OverrideTexture); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mainTexture", _g_get_mainTexture); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Skeleton", _g_get_Skeleton); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "SkeletonData", _g_get_SkeletonData); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsValid", _g_get_IsValid); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AnimationState", _g_get_AnimationState); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PhysicsPositionInheritanceFactor", _g_get_PhysicsPositionInheritanceFactor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PhysicsRotationInheritanceFactor", _g_get_PhysicsRotationInheritanceFactor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PhysicsMovementRelativeTo", _g_get_PhysicsMovementRelativeTo); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "MeshGenerator", _g_get_MeshGenerator); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "SkeletonClipping", _g_get_SkeletonClipping); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "MeshesMultipleCanvasRenderers", _g_get_MeshesMultipleCanvasRenderers); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "MaterialsMultipleCanvasRenderers", _g_get_MaterialsMultipleCanvasRenderers); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "TexturesMultipleCanvasRenderers", _g_get_TexturesMultipleCanvasRenderers); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "UpdateTiming", _g_get_UpdateTiming); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "UnscaledTime", _g_get_UnscaledTime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "skeletonDataAsset", _g_get_skeletonDataAsset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "additiveMaterial", _g_get_additiveMaterial); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "multiplyMaterial", _g_get_multiplyMaterial); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "screenMaterial", _g_get_screenMaterial); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "initialSkinName", _g_get_initialSkinName); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "initialFlipX", _g_get_initialFlipX); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "initialFlipY", _g_get_initialFlipY); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startingAnimation", _g_get_startingAnimation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startingLoop", _g_get_startingLoop); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "timeScale", _g_get_timeScale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "freeze", _g_get_freeze); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "layoutScaleMode", _g_get_layoutScaleMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "updateWhenInvisible", _g_get_updateWhenInvisible); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "allowMultipleCanvasRenderers", _g_get_allowMultipleCanvasRenderers); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "canvasRenderers", _g_get_canvasRenderers); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "separatorSlots", _g_get_separatorSlots); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enableSeparatorSlots", _g_get_enableSeparatorSlots); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "updateSeparatorPartLocation", _g_get_updateSeparatorPartLocation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "updateSeparatorPartScale", _g_get_updateSeparatorPartScale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "disableMeshAssignmentOnOverride", _g_get_disableMeshAssignmentOnOverride); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "color", _s_set_color); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "UpdateMode", _s_set_UpdateMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "OverrideTexture", _s_set_OverrideTexture); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Skeleton", _s_set_Skeleton); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "PhysicsPositionInheritanceFactor", _s_set_PhysicsPositionInheritanceFactor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "PhysicsRotationInheritanceFactor", _s_set_PhysicsRotationInheritanceFactor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "PhysicsMovementRelativeTo", _s_set_PhysicsMovementRelativeTo); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "UpdateTiming", _s_set_UpdateTiming); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "UnscaledTime", _s_set_UnscaledTime); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "skeletonDataAsset", _s_set_skeletonDataAsset); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "additiveMaterial", _s_set_additiveMaterial); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "multiplyMaterial", _s_set_multiplyMaterial); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "screenMaterial", _s_set_screenMaterial); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "initialSkinName", _s_set_initialSkinName); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "initialFlipX", _s_set_initialFlipX); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "initialFlipY", _s_set_initialFlipY); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startingAnimation", _s_set_startingAnimation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startingLoop", _s_set_startingLoop); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "timeScale", _s_set_timeScale); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "freeze", _s_set_freeze); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "layoutScaleMode", _s_set_layoutScaleMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "updateWhenInvisible", _s_set_updateWhenInvisible); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "allowMultipleCanvasRenderers", _s_set_allowMultipleCanvasRenderers); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "canvasRenderers", _s_set_canvasRenderers); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enableSeparatorSlots", _s_set_enableSeparatorSlots); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "updateSeparatorPartLocation", _s_set_updateSeparatorPartLocation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "updateSeparatorPartScale", _s_set_updateSeparatorPartScale); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "disableMeshAssignmentOnOverride", _s_set_disableMeshAssignmentOnOverride); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 5, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "NewSkeletonGraphicGameObject", _m_NewSkeletonGraphicGameObject_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "AddSkeletonGraphicComponent", _m_AddSkeletonGraphicComponent_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetRectTransformSize", _m_SetRectTransformSize_xlua_st_); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SeparatorPartGameObjectName", Spine.Unity.SkeletonGraphic.SeparatorPartGameObjectName); + + + + + 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 Spine.Unity.SkeletonGraphic(); + 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 Spine.Unity.SkeletonGraphic constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_NewSkeletonGraphicGameObject_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + Spine.Unity.SkeletonDataAsset _skeletonDataAsset = (Spine.Unity.SkeletonDataAsset)translator.GetObject(L, 1, typeof(Spine.Unity.SkeletonDataAsset)); + UnityEngine.Transform _parent = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + + var gen_ret = Spine.Unity.SkeletonGraphic.NewSkeletonGraphicGameObject( _skeletonDataAsset, _parent, _material ); + 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_AddSkeletonGraphicComponent_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.GameObject _gameObject = (UnityEngine.GameObject)translator.GetObject(L, 1, typeof(UnityEngine.GameObject)); + Spine.Unity.SkeletonDataAsset _skeletonDataAsset = (Spine.Unity.SkeletonDataAsset)translator.GetObject(L, 2, typeof(Spine.Unity.SkeletonDataAsset)); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + + var gen_ret = Spine.Unity.SkeletonGraphic.AddSkeletonGraphicComponent( _gameObject, _skeletonDataAsset, _material ); + 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_Rebuild(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.UI.CanvasUpdate _update;translator.Get(L, 2, out _update); + + gen_to_be_invoked.Rebuild( _update ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Update(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.Update( ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _deltaTime = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.Update( _deltaTime ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.SkeletonGraphic.Update!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ApplyTransformMovementToPhysics(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ApplyTransformMovementToPhysics( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ApplyAnimation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ApplyAnimation( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AfterAnimationApplied(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.AfterAnimationApplied( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LateUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.LateUpdate( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnBecameVisible(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.OnBecameVisible( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnBecameInvisible(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.OnBecameInvisible( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ReapplySeparatorSlotNames(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ReapplySeparatorSlotNames( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetLastPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ResetLastPosition( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetLastRotation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ResetLastRotation( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetLastPositionAndRotation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ResetLastPositionAndRotation( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetLastMesh(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetLastMesh( ); + 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_MatchRectTransformWithBounds(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.MatchRectTransformWithBounds( ); + 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_SetRectTransformSize_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.UI.Graphic _target = (UnityEngine.UI.Graphic)translator.GetObject(L, 1, typeof(UnityEngine.UI.Graphic)); + UnityEngine.Vector2 _size;translator.Get(L, 2, out _size); + + Spine.Unity.SkeletonGraphic.SetRectTransformSize( _target, _size ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.RectTransform _targetRectTransform = (UnityEngine.RectTransform)translator.GetObject(L, 1, typeof(UnityEngine.RectTransform)); + UnityEngine.Vector2 _size;translator.Get(L, 2, out _size); + + Spine.Unity.SkeletonGraphic.SetRectTransformSize( _targetRectTransform, _size ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.SkeletonGraphic.SetRectTransformSize!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Clear(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Clear( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TrimRenderers(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.TrimRenderers( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Initialize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + + + + { + bool _overwrite = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.Initialize( _overwrite ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PrepareInstructionsAndRenderers(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _isInRebuild = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.PrepareInstructionsAndRenderers( _isInRebuild ); + + + + return 0; + } + if(gen_param_count == 1) + { + + gen_to_be_invoked.PrepareInstructionsAndRenderers( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.SkeletonGraphic.PrepareInstructionsAndRenderers!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UpdateMesh(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.UpdateMesh( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UpdateMeshToInstructions(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.UpdateMeshToInstructions( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasMultipleSubmeshInstructions(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.HasMultipleSubmeshInstructions( ); + 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_SetScaledPivotOffset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector2 _pivotOffsetScaled;translator.Get(L, 2, out _pivotOffsetScaled); + + gen_to_be_invoked.SetScaledPivotOffset( _pivotOffsetScaled ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_SkeletonDataAsset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.SkeletonDataAsset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_color(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineColor(L, gen_to_be_invoked.color); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_MeshScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.MeshScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_MeshOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.MeshOffset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UpdateMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.UpdateMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_SeparatorParts(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.SeparatorParts); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_CustomTextureOverride(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.CustomTextureOverride); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_CustomMaterialOverride(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.CustomMaterialOverride); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_OverrideTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.OverrideTexture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mainTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.mainTexture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Skeleton(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Skeleton); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_SkeletonData(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.SkeletonData); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsValid(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsValid); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AnimationState(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.AnimationState); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PhysicsPositionInheritanceFactor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.PhysicsPositionInheritanceFactor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PhysicsRotationInheritanceFactor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.PhysicsRotationInheritanceFactor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PhysicsMovementRelativeTo(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.PhysicsMovementRelativeTo); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_MeshGenerator(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.MeshGenerator); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_SkeletonClipping(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.SkeletonClipping); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_MeshesMultipleCanvasRenderers(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.MeshesMultipleCanvasRenderers); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_MaterialsMultipleCanvasRenderers(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.MaterialsMultipleCanvasRenderers); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_TexturesMultipleCanvasRenderers(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.TexturesMultipleCanvasRenderers); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UpdateTiming(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.UpdateTiming); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UnscaledTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.UnscaledTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_skeletonDataAsset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.skeletonDataAsset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_additiveMaterial(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.additiveMaterial); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_multiplyMaterial(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.multiplyMaterial); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_screenMaterial(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.screenMaterial); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_initialSkinName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.initialSkinName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_initialFlipX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.initialFlipX); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_initialFlipY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.initialFlipY); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startingAnimation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.startingAnimation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startingLoop(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.startingLoop); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_timeScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.timeScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_freeze(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.freeze); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_layoutScaleMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + translator.PushSpineUnitySkeletonGraphicLayoutMode(L, gen_to_be_invoked.layoutScaleMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_updateWhenInvisible(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.updateWhenInvisible); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_allowMultipleCanvasRenderers(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.allowMultipleCanvasRenderers); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_canvasRenderers(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.canvasRenderers); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_separatorSlots(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.separatorSlots); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enableSeparatorSlots(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.enableSeparatorSlots); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_updateSeparatorPartLocation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.updateSeparatorPartLocation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_updateSeparatorPartScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.updateSeparatorPartScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_disableMeshAssignmentOnOverride(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.disableMeshAssignmentOnOverride); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_color(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + UnityEngine.Color gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.color = 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_UpdateMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + Spine.Unity.UpdateMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.UpdateMode = 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_OverrideTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.OverrideTexture = (UnityEngine.Texture)translator.GetObject(L, 2, typeof(UnityEngine.Texture)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Skeleton(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Skeleton = (Spine.Skeleton)translator.GetObject(L, 2, typeof(Spine.Skeleton)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_PhysicsPositionInheritanceFactor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.PhysicsPositionInheritanceFactor = 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_PhysicsRotationInheritanceFactor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.PhysicsRotationInheritanceFactor = (float)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_PhysicsMovementRelativeTo(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.PhysicsMovementRelativeTo = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_UpdateTiming(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + Spine.Unity.UpdateTiming gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.UpdateTiming = 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_UnscaledTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.UnscaledTime = 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_skeletonDataAsset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.skeletonDataAsset = (Spine.Unity.SkeletonDataAsset)translator.GetObject(L, 2, typeof(Spine.Unity.SkeletonDataAsset)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_additiveMaterial(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.additiveMaterial = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_multiplyMaterial(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.multiplyMaterial = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_screenMaterial(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.screenMaterial = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_initialSkinName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.initialSkinName = 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_initialFlipX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.initialFlipX = 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_initialFlipY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.initialFlipY = 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_startingAnimation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.startingAnimation = 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_startingLoop(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.startingLoop = 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_timeScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.timeScale = (float)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_freeze(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.freeze = 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_layoutScaleMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + Spine.Unity.SkeletonGraphic.LayoutMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.layoutScaleMode = 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_updateWhenInvisible(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + Spine.Unity.UpdateMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.updateWhenInvisible = 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_allowMultipleCanvasRenderers(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.allowMultipleCanvasRenderers = 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_canvasRenderers(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.canvasRenderers = (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; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_enableSeparatorSlots(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.enableSeparatorSlots = 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_updateSeparatorPartLocation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.updateSeparatorPartLocation = 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_updateSeparatorPartScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.updateSeparatorPartScale = 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_disableMeshAssignmentOnOverride(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.disableMeshAssignmentOnOverride = 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 _e_AssignMeshOverrideSingleRenderer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + Spine.Unity.SkeletonGraphic.MeshAssignmentDelegateSingle gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.Unity.SkeletonGraphic.MeshAssignmentDelegateSingle!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.AssignMeshOverrideSingleRenderer += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.AssignMeshOverrideSingleRenderer -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.SkeletonGraphic.AssignMeshOverrideSingleRenderer!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_AssignMeshOverrideMultipleRenderers(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + Spine.Unity.SkeletonGraphic.MeshAssignmentDelegateMultiple gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.Unity.SkeletonGraphic.MeshAssignmentDelegateMultiple!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.AssignMeshOverrideMultipleRenderers += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.AssignMeshOverrideMultipleRenderers -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.SkeletonGraphic.AssignMeshOverrideMultipleRenderers!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnRebuild(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + Spine.Unity.SkeletonGraphic.SkeletonRendererDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.Unity.SkeletonGraphic.SkeletonRendererDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnRebuild += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnRebuild -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.SkeletonGraphic.OnRebuild!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnInstructionsPrepared(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + Spine.Unity.SkeletonGraphic.InstructionDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.Unity.SkeletonGraphic.InstructionDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnInstructionsPrepared += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnInstructionsPrepared -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.SkeletonGraphic.OnInstructionsPrepared!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnMeshAndMaterialsUpdated(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + Spine.Unity.SkeletonGraphic.SkeletonRendererDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.Unity.SkeletonGraphic.SkeletonRendererDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnMeshAndMaterialsUpdated += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnMeshAndMaterialsUpdated -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.SkeletonGraphic.OnMeshAndMaterialsUpdated!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnAnimationRebuild(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + Spine.Unity.ISkeletonAnimationDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.Unity.ISkeletonAnimationDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnAnimationRebuild += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnAnimationRebuild -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.SkeletonGraphic.OnAnimationRebuild!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_BeforeApply(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + Spine.Unity.UpdateBonesDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.Unity.UpdateBonesDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.BeforeApply += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.BeforeApply -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.SkeletonGraphic.BeforeApply!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_UpdateLocal(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + Spine.Unity.UpdateBonesDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.Unity.UpdateBonesDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.UpdateLocal += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.UpdateLocal -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.SkeletonGraphic.UpdateLocal!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_UpdateWorld(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + Spine.Unity.UpdateBonesDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.Unity.UpdateBonesDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.UpdateWorld += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.UpdateWorld -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.SkeletonGraphic.UpdateWorld!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_UpdateComplete(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + Spine.Unity.UpdateBonesDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.Unity.UpdateBonesDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.UpdateComplete += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.UpdateComplete -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.SkeletonGraphic.UpdateComplete!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnPostProcessVertices(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.Unity.SkeletonGraphic gen_to_be_invoked = (Spine.Unity.SkeletonGraphic)translator.FastGetCSObj(L, 1); + Spine.Unity.MeshGeneratorDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.Unity.MeshGeneratorDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnPostProcessVertices += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnPostProcessVertices -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.SkeletonGraphic.OnPostProcessVertices!"); + return 0; + } + + + + } +} diff --git a/Assets/XLua/Gen/Spine_Unity_SkeletonRendererWrap.cs b/Assets/XLua/Gen/Spine_Unity_SkeletonRendererWrap.cs new file mode 100644 index 000000000..0c5087d43 --- /dev/null +++ b/Assets/XLua/Gen/Spine_Unity_SkeletonRendererWrap.cs @@ -0,0 +1,1566 @@ +#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 SpineUnitySkeletonRendererWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(Spine.Unity.SkeletonRenderer); + Utils.BeginObjectRegister(type, L, translator, 0, 19, 30, 24); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetLastPosition", _m_ResetLastPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetLastRotation", _m_ResetLastRotation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetLastPositionAndRotation", _m_ResetLastPositionAndRotation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMeshSettings", _m_SetMeshSettings); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Awake", _m_Awake); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearState", _m_ClearState); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "EnsureMeshGeneratorCapacity", _m_EnsureMeshGeneratorCapacity); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Initialize", _m_Initialize); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ApplyTransformMovementToPhysics", _m_ApplyTransformMovementToPhysics); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LateUpdate", _m_LateUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LateUpdateMesh", _m_LateUpdateMesh); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBecameVisible", _m_OnBecameVisible); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBecameInvisible", _m_OnBecameInvisible); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindAndApplySeparatorSlots", _m_FindAndApplySeparatorSlots); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ReapplySeparatorSlotNames", _m_ReapplySeparatorSlotNames); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GenerateMeshOverride", _e_GenerateMeshOverride); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPostProcessVertices", _e_OnPostProcessVertices); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnRebuild", _e_OnRebuild); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnMeshAndMaterialsUpdated", _e_OnMeshAndMaterialsUpdated); + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "UpdateMode", _g_get_UpdateMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "CustomMaterialOverride", _g_get_CustomMaterialOverride); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "CustomSlotMaterials", _g_get_CustomSlotMaterials); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "SkeletonClipping", _g_get_SkeletonClipping); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Skeleton", _g_get_Skeleton); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PhysicsPositionInheritanceFactor", _g_get_PhysicsPositionInheritanceFactor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PhysicsRotationInheritanceFactor", _g_get_PhysicsRotationInheritanceFactor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PhysicsMovementRelativeTo", _g_get_PhysicsMovementRelativeTo); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "SkeletonDataAsset", _g_get_SkeletonDataAsset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "skeletonDataAsset", _g_get_skeletonDataAsset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "initialSkinName", _g_get_initialSkinName); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "initialFlipX", _g_get_initialFlipX); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "initialFlipY", _g_get_initialFlipY); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "updateWhenInvisible", _g_get_updateWhenInvisible); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "separatorSlots", _g_get_separatorSlots); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "zSpacing", _g_get_zSpacing); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "useClipping", _g_get_useClipping); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "immutableTriangles", _g_get_immutableTriangles); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "pmaVertexColors", _g_get_pmaVertexColors); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "clearStateOnDisable", _g_get_clearStateOnDisable); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "tintBlack", _g_get_tintBlack); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "singleSubmesh", _g_get_singleSubmesh); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fixDrawOrder", _g_get_fixDrawOrder); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "addNormals", _g_get_addNormals); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "calculateTangents", _g_get_calculateTangents); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "maskInteraction", _g_get_maskInteraction); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "maskMaterials", _g_get_maskMaterials); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "disableRenderingOnOverride", _g_get_disableRenderingOnOverride); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "valid", _g_get_valid); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "skeleton", _g_get_skeleton); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "UpdateMode", _s_set_UpdateMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "PhysicsPositionInheritanceFactor", _s_set_PhysicsPositionInheritanceFactor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "PhysicsRotationInheritanceFactor", _s_set_PhysicsRotationInheritanceFactor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "PhysicsMovementRelativeTo", _s_set_PhysicsMovementRelativeTo); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "skeletonDataAsset", _s_set_skeletonDataAsset); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "initialSkinName", _s_set_initialSkinName); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "initialFlipX", _s_set_initialFlipX); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "initialFlipY", _s_set_initialFlipY); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "updateWhenInvisible", _s_set_updateWhenInvisible); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "zSpacing", _s_set_zSpacing); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "useClipping", _s_set_useClipping); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "immutableTriangles", _s_set_immutableTriangles); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "pmaVertexColors", _s_set_pmaVertexColors); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "clearStateOnDisable", _s_set_clearStateOnDisable); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "tintBlack", _s_set_tintBlack); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "singleSubmesh", _s_set_singleSubmesh); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fixDrawOrder", _s_set_fixDrawOrder); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "addNormals", _s_set_addNormals); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "calculateTangents", _s_set_calculateTangents); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "maskInteraction", _s_set_maskInteraction); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "maskMaterials", _s_set_maskMaterials); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "disableRenderingOnOverride", _s_set_disableRenderingOnOverride); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "valid", _s_set_valid); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "skeleton", _s_set_skeleton); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 6, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "STENCIL_COMP_PARAM_ID", Spine.Unity.SkeletonRenderer.STENCIL_COMP_PARAM_ID); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "STENCIL_COMP_MASKINTERACTION_NONE", Spine.Unity.SkeletonRenderer.STENCIL_COMP_MASKINTERACTION_NONE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "STENCIL_COMP_MASKINTERACTION_VISIBLE_INSIDE", Spine.Unity.SkeletonRenderer.STENCIL_COMP_MASKINTERACTION_VISIBLE_INSIDE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "STENCIL_COMP_MASKINTERACTION_VISIBLE_OUTSIDE", Spine.Unity.SkeletonRenderer.STENCIL_COMP_MASKINTERACTION_VISIBLE_OUTSIDE); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SUBMESH_DUMMY_PARAM_ID", Spine.Unity.SkeletonRenderer.SUBMESH_DUMMY_PARAM_ID); + + + + + 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 Spine.Unity.SkeletonRenderer(); + 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 Spine.Unity.SkeletonRenderer constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetLastPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ResetLastPosition( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetLastRotation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ResetLastRotation( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetLastPositionAndRotation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ResetLastPositionAndRotation( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMeshSettings(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + + + + { + Spine.Unity.MeshGenerator.Settings _settings;translator.Get(L, 2, out _settings); + + gen_to_be_invoked.SetMeshSettings( _settings ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Awake(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Awake( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearState(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearState( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_EnsureMeshGeneratorCapacity(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + + + + { + int _minimumVertexCount = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.EnsureMeshGeneratorCapacity( _minimumVertexCount ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Initialize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + bool _overwrite = LuaAPI.lua_toboolean(L, 2); + bool _quiet = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.Initialize( _overwrite, _quiet ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _overwrite = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.Initialize( _overwrite ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.SkeletonRenderer.Initialize!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ApplyTransformMovementToPhysics(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ApplyTransformMovementToPhysics( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LateUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.LateUpdate( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LateUpdateMesh(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.LateUpdateMesh( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnBecameVisible(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.OnBecameVisible( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnBecameInvisible(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.OnBecameInvisible( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FindAndApplySeparatorSlots(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + string _startsWith = LuaAPI.lua_tostring(L, 2); + bool _clearExistingSeparators = LuaAPI.lua_toboolean(L, 3); + bool _updateStringArray = LuaAPI.lua_toboolean(L, 4); + + gen_to_be_invoked.FindAndApplySeparatorSlots( _startsWith, _clearExistingSeparators, _updateStringArray ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + string _startsWith = LuaAPI.lua_tostring(L, 2); + bool _clearExistingSeparators = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.FindAndApplySeparatorSlots( _startsWith, _clearExistingSeparators ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _startsWith = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.FindAndApplySeparatorSlots( _startsWith ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + System.Func _slotNamePredicate = translator.GetDelegate>(L, 2); + bool _clearExistingSeparators = LuaAPI.lua_toboolean(L, 3); + bool _updateStringArray = LuaAPI.lua_toboolean(L, 4); + + gen_to_be_invoked.FindAndApplySeparatorSlots( _slotNamePredicate, _clearExistingSeparators, _updateStringArray ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + System.Func _slotNamePredicate = translator.GetDelegate>(L, 2); + bool _clearExistingSeparators = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.FindAndApplySeparatorSlots( _slotNamePredicate, _clearExistingSeparators ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Func _slotNamePredicate = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.FindAndApplySeparatorSlots( _slotNamePredicate ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.SkeletonRenderer.FindAndApplySeparatorSlots!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ReapplySeparatorSlotNames(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ReapplySeparatorSlotNames( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UpdateMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.UpdateMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_CustomMaterialOverride(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.CustomMaterialOverride); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_CustomSlotMaterials(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.CustomSlotMaterials); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_SkeletonClipping(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.SkeletonClipping); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Skeleton(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Skeleton); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PhysicsPositionInheritanceFactor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.PhysicsPositionInheritanceFactor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PhysicsRotationInheritanceFactor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.PhysicsRotationInheritanceFactor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PhysicsMovementRelativeTo(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.PhysicsMovementRelativeTo); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_SkeletonDataAsset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.SkeletonDataAsset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_skeletonDataAsset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.skeletonDataAsset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_initialSkinName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.initialSkinName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_initialFlipX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.initialFlipX); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_initialFlipY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.initialFlipY); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_updateWhenInvisible(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.updateWhenInvisible); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_separatorSlots(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.separatorSlots); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_zSpacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.zSpacing); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_useClipping(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.useClipping); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_immutableTriangles(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.immutableTriangles); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_pmaVertexColors(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.pmaVertexColors); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_clearStateOnDisable(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.clearStateOnDisable); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_tintBlack(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.tintBlack); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_singleSubmesh(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.singleSubmesh); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fixDrawOrder(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.fixDrawOrder); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_addNormals(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.addNormals); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_calculateTangents(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.calculateTangents); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maskInteraction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.maskInteraction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maskMaterials(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.maskMaterials); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_disableRenderingOnOverride(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.disableRenderingOnOverride); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_valid(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.valid); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_skeleton(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.skeleton); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_UpdateMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + Spine.Unity.UpdateMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.UpdateMode = 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_PhysicsPositionInheritanceFactor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.PhysicsPositionInheritanceFactor = 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_PhysicsRotationInheritanceFactor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.PhysicsRotationInheritanceFactor = (float)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_PhysicsMovementRelativeTo(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.PhysicsMovementRelativeTo = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_skeletonDataAsset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.skeletonDataAsset = (Spine.Unity.SkeletonDataAsset)translator.GetObject(L, 2, typeof(Spine.Unity.SkeletonDataAsset)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_initialSkinName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.initialSkinName = 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_initialFlipX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.initialFlipX = 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_initialFlipY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.initialFlipY = 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_updateWhenInvisible(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + Spine.Unity.UpdateMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.updateWhenInvisible = 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_zSpacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.zSpacing = (float)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_useClipping(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.useClipping = 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_immutableTriangles(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.immutableTriangles = 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_pmaVertexColors(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.pmaVertexColors = 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_clearStateOnDisable(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.clearStateOnDisable = 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_tintBlack(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.tintBlack = 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_singleSubmesh(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.singleSubmesh = 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_fixDrawOrder(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.fixDrawOrder = 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_addNormals(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.addNormals = 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_calculateTangents(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.calculateTangents = 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_maskInteraction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + UnityEngine.SpriteMaskInteraction gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.maskInteraction = 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_maskMaterials(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.maskMaterials = (Spine.Unity.SkeletonRenderer.SpriteMaskInteractionMaterials)translator.GetObject(L, 2, typeof(Spine.Unity.SkeletonRenderer.SpriteMaskInteractionMaterials)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_disableRenderingOnOverride(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.disableRenderingOnOverride = 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_valid(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.valid = 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_skeleton(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.skeleton = (Spine.Skeleton)translator.GetObject(L, 2, typeof(Spine.Skeleton)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_GenerateMeshOverride(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + Spine.Unity.SkeletonRenderer.InstructionDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.Unity.SkeletonRenderer.InstructionDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.GenerateMeshOverride += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.GenerateMeshOverride -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.SkeletonRenderer.GenerateMeshOverride!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnPostProcessVertices(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + Spine.Unity.MeshGeneratorDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.Unity.MeshGeneratorDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnPostProcessVertices += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnPostProcessVertices -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.SkeletonRenderer.OnPostProcessVertices!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnRebuild(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + Spine.Unity.SkeletonRenderer.SkeletonRendererDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.Unity.SkeletonRenderer.SkeletonRendererDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnRebuild += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnRebuild -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.SkeletonRenderer.OnRebuild!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnMeshAndMaterialsUpdated(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + Spine.Unity.SkeletonRenderer gen_to_be_invoked = (Spine.Unity.SkeletonRenderer)translator.FastGetCSObj(L, 1); + Spine.Unity.SkeletonRenderer.SkeletonRendererDelegate gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need Spine.Unity.SkeletonRenderer.SkeletonRendererDelegate!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnMeshAndMaterialsUpdated += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnMeshAndMaterialsUpdated -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to Spine.Unity.SkeletonRenderer.OnMeshAndMaterialsUpdated!"); + return 0; + } + + + + } +} diff --git a/Assets/XLua/Gen/Spine_Unity_SkeletonRenderer_SpriteMaskInteractionMaterialsWrap.cs b/Assets/XLua/Gen/Spine_Unity_SkeletonRenderer_SpriteMaskInteractionMaterialsWrap.cs new file mode 100644 index 000000000..e8f3fb5fd --- /dev/null +++ b/Assets/XLua/Gen/Spine_Unity_SkeletonRenderer_SpriteMaskInteractionMaterialsWrap.cs @@ -0,0 +1,192 @@ +#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 SpineUnitySkeletonRendererSpriteMaskInteractionMaterialsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(Spine.Unity.SkeletonRenderer.SpriteMaskInteractionMaterials); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 4, 3); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AnyMaterialCreated", _g_get_AnyMaterialCreated); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "materialsMaskDisabled", _g_get_materialsMaskDisabled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "materialsInsideMask", _g_get_materialsInsideMask); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "materialsOutsideMask", _g_get_materialsOutsideMask); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "materialsMaskDisabled", _s_set_materialsMaskDisabled); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "materialsInsideMask", _s_set_materialsInsideMask); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "materialsOutsideMask", _s_set_materialsOutsideMask); + + + 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 Spine.Unity.SkeletonRenderer.SpriteMaskInteractionMaterials(); + 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 Spine.Unity.SkeletonRenderer.SpriteMaskInteractionMaterials constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AnyMaterialCreated(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer.SpriteMaskInteractionMaterials gen_to_be_invoked = (Spine.Unity.SkeletonRenderer.SpriteMaskInteractionMaterials)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.AnyMaterialCreated); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_materialsMaskDisabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer.SpriteMaskInteractionMaterials gen_to_be_invoked = (Spine.Unity.SkeletonRenderer.SpriteMaskInteractionMaterials)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.materialsMaskDisabled); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_materialsInsideMask(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer.SpriteMaskInteractionMaterials gen_to_be_invoked = (Spine.Unity.SkeletonRenderer.SpriteMaskInteractionMaterials)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.materialsInsideMask); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_materialsOutsideMask(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer.SpriteMaskInteractionMaterials gen_to_be_invoked = (Spine.Unity.SkeletonRenderer.SpriteMaskInteractionMaterials)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.materialsOutsideMask); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_materialsMaskDisabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer.SpriteMaskInteractionMaterials gen_to_be_invoked = (Spine.Unity.SkeletonRenderer.SpriteMaskInteractionMaterials)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.materialsMaskDisabled = (UnityEngine.Material[])translator.GetObject(L, 2, typeof(UnityEngine.Material[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_materialsInsideMask(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer.SpriteMaskInteractionMaterials gen_to_be_invoked = (Spine.Unity.SkeletonRenderer.SpriteMaskInteractionMaterials)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.materialsInsideMask = (UnityEngine.Material[])translator.GetObject(L, 2, typeof(UnityEngine.Material[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_materialsOutsideMask(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + Spine.Unity.SkeletonRenderer.SpriteMaskInteractionMaterials gen_to_be_invoked = (Spine.Unity.SkeletonRenderer.SpriteMaskInteractionMaterials)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.materialsOutsideMask = (UnityEngine.Material[])translator.GetObject(L, 2, typeof(UnityEngine.Material[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/StorageRequestWrap.cs b/Assets/XLua/Gen/StorageRequestWrap.cs new file mode 100644 index 000000000..50a835d6d --- /dev/null +++ b/Assets/XLua/Gen/StorageRequestWrap.cs @@ -0,0 +1,306 @@ +#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 StorageRequestWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(StorageRequest); + Utils.BeginObjectRegister(type, L, translator, 0, 5, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Write", _m_Write); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Read", _m_Read); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Update", _m_Update); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Delete", _m_Delete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Batch", _m_Batch); + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 1, 0); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "Instance", _g_get_Instance); + + + + 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 StorageRequest(); + 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 StorageRequest constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Write(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + StorageRequest gen_to_be_invoked = (StorageRequest)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 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 _body = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.Write( _key, _body ); + + + + return 0; + } + if(gen_param_count == 4&& (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)&& translator.Assignable>(L, 4)) + { + string _key = LuaAPI.lua_tostring(L, 2); + string _body = LuaAPI.lua_tostring(L, 3); + System.Action _complete = translator.GetDelegate>(L, 4); + + gen_to_be_invoked.Write( _key, _body, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to StorageRequest.Write!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Read(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + StorageRequest gen_to_be_invoked = (StorageRequest)translator.FastGetCSObj(L, 1); + + + + { + string _key = LuaAPI.lua_tostring(L, 2); + string _body = LuaAPI.lua_tostring(L, 3); + System.Action _complete = translator.GetDelegate>(L, 4); + + gen_to_be_invoked.Read( _key, _body, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Update(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + StorageRequest gen_to_be_invoked = (StorageRequest)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 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 _body = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.Update( _key, _body ); + + + + return 0; + } + if(gen_param_count == 4&& (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)&& translator.Assignable>(L, 4)) + { + string _key = LuaAPI.lua_tostring(L, 2); + string _body = LuaAPI.lua_tostring(L, 3); + System.Action _complete = translator.GetDelegate>(L, 4); + + gen_to_be_invoked.Update( _key, _body, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to StorageRequest.Update!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Delete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + StorageRequest gen_to_be_invoked = (StorageRequest)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _key = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.Delete( _key ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 3)) + { + string _key = LuaAPI.lua_tostring(L, 2); + System.Action _complete = translator.GetDelegate>(L, 3); + + gen_to_be_invoked.Delete( _key, _complete ); + + + + return 0; + } + if(gen_param_count == 4&& (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)&& translator.Assignable>(L, 4)) + { + string _key = LuaAPI.lua_tostring(L, 2); + string _deleteKeys = LuaAPI.lua_tostring(L, 3); + System.Action _complete = translator.GetDelegate>(L, 4); + + gen_to_be_invoked.Delete( _key, _deleteKeys, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to StorageRequest.Delete!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Batch(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + StorageRequest gen_to_be_invoked = (StorageRequest)translator.FastGetCSObj(L, 1); + + + + { + string _body = LuaAPI.lua_tostring(L, 2); + System.Action _complete = translator.GetDelegate>(L, 3); + + gen_to_be_invoked.Batch( _body, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Instance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, StorageRequest.Instance); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/System_Collections_Generic_List_1_BF_BFFinger_Wrap.cs b/Assets/XLua/Gen/System_Collections_Generic_List_1_BF_BFFinger_Wrap.cs new file mode 100644 index 000000000..47001060c --- /dev/null +++ b/Assets/XLua/Gen/System_Collections_Generic_List_1_BF_BFFinger_Wrap.cs @@ -0,0 +1,1279 @@ +#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 SystemCollectionsGenericList_1_BFBFFinger_Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(System.Collections.Generic.List); + Utils.BeginObjectRegister(type, L, translator, 0, 29, 2, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Add", _m_Add); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddRange", _m_AddRange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AsReadOnly", _m_AsReadOnly); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "BinarySearch", _m_BinarySearch); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Contains", _m_Contains); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CopyTo", _m_CopyTo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Exists", _m_Exists); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Find", _m_Find); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindAll", _m_FindAll); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindIndex", _m_FindIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindLast", _m_FindLast); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindLastIndex", _m_FindLastIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ForEach", _m_ForEach); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetEnumerator", _m_GetEnumerator); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetRange", _m_GetRange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IndexOf", _m_IndexOf); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Insert", _m_Insert); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InsertRange", _m_InsertRange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LastIndexOf", _m_LastIndexOf); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Remove", _m_Remove); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveAll", _m_RemoveAll); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveAt", _m_RemoveAt); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveRange", _m_RemoveRange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Reverse", _m_Reverse); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Sort", _m_Sort); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToArray", _m_ToArray); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TrimExcess", _m_TrimExcess); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TrueForAll", _m_TrueForAll); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Capacity", _g_get_Capacity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Count", _g_get_Count); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Capacity", _s_set_Capacity); + + + Utils.EndObjectRegister(type, L, translator, __CSIndexer, __NewIndexer, + 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 System.Collections.Generic.List(); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _capacity = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = new System.Collections.Generic.List(_capacity); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && translator.Assignable>(L, 2)) + { + System.Collections.Generic.IEnumerable _collection = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEnumerable)); + + var gen_ret = new System.Collections.Generic.List(_collection); + 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 System.Collections.Generic.List constructor!"); + + } + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __CSIndexer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + if (translator.Assignable>(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + int index = LuaAPI.xlua_tointeger(L, 2); + LuaAPI.lua_pushboolean(L, true); + translator.Push(L, gen_to_be_invoked[index]); + return 2; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __NewIndexer(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + try { + + if (translator.Assignable>(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && translator.Assignable(L, 3)) + { + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + int key = LuaAPI.xlua_tointeger(L, 2); + gen_to_be_invoked[key] = (BF.BFFinger)translator.GetObject(L, 3, typeof(BF.BFFinger)); + LuaAPI.lua_pushboolean(L, true); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Add(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + BF.BFFinger _item = (BF.BFFinger)translator.GetObject(L, 2, typeof(BF.BFFinger)); + + gen_to_be_invoked.Add( _item ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddRange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.IEnumerable _collection = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEnumerable)); + + gen_to_be_invoked.AddRange( _collection ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AsReadOnly(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.AsReadOnly( ); + 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_BinarySearch(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + BF.BFFinger _item = (BF.BFFinger)translator.GetObject(L, 2, typeof(BF.BFFinger)); + + var gen_ret = gen_to_be_invoked.BinarySearch( _item ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable>(L, 3)) + { + BF.BFFinger _item = (BF.BFFinger)translator.GetObject(L, 2, typeof(BF.BFFinger)); + System.Collections.Generic.IComparer _comparer = (System.Collections.Generic.IComparer)translator.GetObject(L, 3, typeof(System.Collections.Generic.IComparer)); + + var gen_ret = gen_to_be_invoked.BinarySearch( _item, _comparer ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable>(L, 5)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + BF.BFFinger _item = (BF.BFFinger)translator.GetObject(L, 4, typeof(BF.BFFinger)); + System.Collections.Generic.IComparer _comparer = (System.Collections.Generic.IComparer)translator.GetObject(L, 5, typeof(System.Collections.Generic.IComparer)); + + var gen_ret = gen_to_be_invoked.BinarySearch( _index, _count, _item, _comparer ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.BinarySearch!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Clear(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Clear( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Contains(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + BF.BFFinger _item = (BF.BFFinger)translator.GetObject(L, 2, typeof(BF.BFFinger)); + + var gen_ret = gen_to_be_invoked.Contains( _item ); + 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_CopyTo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + BF.BFFinger[] _array = (BF.BFFinger[])translator.GetObject(L, 2, typeof(BF.BFFinger[])); + + gen_to_be_invoked.CopyTo( _array ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + BF.BFFinger[] _array = (BF.BFFinger[])translator.GetObject(L, 2, typeof(BF.BFFinger[])); + int _arrayIndex = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.CopyTo( _array, _arrayIndex ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + BF.BFFinger[] _array = (BF.BFFinger[])translator.GetObject(L, 3, typeof(BF.BFFinger[])); + int _arrayIndex = LuaAPI.xlua_tointeger(L, 4); + int _count = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.CopyTo( _index, _array, _arrayIndex, _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.List.CopyTo!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Exists(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.Exists( _match ); + 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_Find(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.Find( _match ); + 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_FindAll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.FindAll( _match ); + 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_FindIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.FindIndex( _match ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + System.Predicate _match = translator.GetDelegate>(L, 3); + + var gen_ret = gen_to_be_invoked.FindIndex( _startIndex, _match ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable>(L, 4)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + System.Predicate _match = translator.GetDelegate>(L, 4); + + var gen_ret = gen_to_be_invoked.FindIndex( _startIndex, _count, _match ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.FindIndex!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FindLast(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.FindLast( _match ); + 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_FindLastIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.FindLastIndex( _match ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + System.Predicate _match = translator.GetDelegate>(L, 3); + + var gen_ret = gen_to_be_invoked.FindLastIndex( _startIndex, _match ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable>(L, 4)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + System.Predicate _match = translator.GetDelegate>(L, 4); + + var gen_ret = gen_to_be_invoked.FindLastIndex( _startIndex, _count, _match ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.FindLastIndex!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ForEach(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.ForEach( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetEnumerator(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetEnumerator( ); + 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_GetRange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.GetRange( _index, _count ); + 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_IndexOf(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + BF.BFFinger _item = (BF.BFFinger)translator.GetObject(L, 2, typeof(BF.BFFinger)); + + var gen_ret = gen_to_be_invoked.IndexOf( _item ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + BF.BFFinger _item = (BF.BFFinger)translator.GetObject(L, 2, typeof(BF.BFFinger)); + int _index = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.IndexOf( _item, _index ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + BF.BFFinger _item = (BF.BFFinger)translator.GetObject(L, 2, typeof(BF.BFFinger)); + int _index = LuaAPI.xlua_tointeger(L, 3); + int _count = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.IndexOf( _item, _index, _count ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.IndexOf!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Insert(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + BF.BFFinger _item = (BF.BFFinger)translator.GetObject(L, 3, typeof(BF.BFFinger)); + + gen_to_be_invoked.Insert( _index, _item ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_InsertRange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.IEnumerable _collection = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 3, typeof(System.Collections.Generic.IEnumerable)); + + gen_to_be_invoked.InsertRange( _index, _collection ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LastIndexOf(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + BF.BFFinger _item = (BF.BFFinger)translator.GetObject(L, 2, typeof(BF.BFFinger)); + + var gen_ret = gen_to_be_invoked.LastIndexOf( _item ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + BF.BFFinger _item = (BF.BFFinger)translator.GetObject(L, 2, typeof(BF.BFFinger)); + int _index = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.LastIndexOf( _item, _index ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + BF.BFFinger _item = (BF.BFFinger)translator.GetObject(L, 2, typeof(BF.BFFinger)); + int _index = LuaAPI.xlua_tointeger(L, 3); + int _count = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.LastIndexOf( _item, _index, _count ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.LastIndexOf!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Remove(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + BF.BFFinger _item = (BF.BFFinger)translator.GetObject(L, 2, typeof(BF.BFFinger)); + + var gen_ret = gen_to_be_invoked.Remove( _item ); + 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_RemoveAll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.RemoveAll( _match ); + 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_RemoveAt(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.RemoveAt( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveRange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.RemoveRange( _index, _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Reverse(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.Reverse( ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.Reverse( _index, _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.List.Reverse!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Sort(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.Sort( ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.IComparer _comparer = (System.Collections.Generic.IComparer)translator.GetObject(L, 2, typeof(System.Collections.Generic.IComparer)); + + gen_to_be_invoked.Sort( _comparer ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Comparison _comparison = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.Sort( _comparison ); + + + + return 0; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable>(L, 4)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + System.Collections.Generic.IComparer _comparer = (System.Collections.Generic.IComparer)translator.GetObject(L, 4, typeof(System.Collections.Generic.IComparer)); + + gen_to_be_invoked.Sort( _index, _count, _comparer ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.List.Sort!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToArray(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.ToArray( ); + 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_TrimExcess(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.TrimExcess( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TrueForAll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.TrueForAll( _match ); + 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 _g_get_Capacity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Capacity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Count(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Count); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Capacity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Capacity = 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/System_Collections_Generic_List_1_System_Collections_Generic_List_1_System_String__Wrap.cs b/Assets/XLua/Gen/System_Collections_Generic_List_1_System_Collections_Generic_List_1_System_String__Wrap.cs new file mode 100644 index 000000000..ed6e262bb --- /dev/null +++ b/Assets/XLua/Gen/System_Collections_Generic_List_1_System_Collections_Generic_List_1_System_String__Wrap.cs @@ -0,0 +1,1279 @@ +#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 SystemCollectionsGenericList_1_SystemCollectionsGenericList_1_SystemString__Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(System.Collections.Generic.List>); + Utils.BeginObjectRegister(type, L, translator, 0, 29, 2, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Add", _m_Add); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddRange", _m_AddRange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AsReadOnly", _m_AsReadOnly); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "BinarySearch", _m_BinarySearch); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Contains", _m_Contains); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CopyTo", _m_CopyTo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Exists", _m_Exists); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Find", _m_Find); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindAll", _m_FindAll); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindIndex", _m_FindIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindLast", _m_FindLast); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindLastIndex", _m_FindLastIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ForEach", _m_ForEach); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetEnumerator", _m_GetEnumerator); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetRange", _m_GetRange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IndexOf", _m_IndexOf); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Insert", _m_Insert); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InsertRange", _m_InsertRange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LastIndexOf", _m_LastIndexOf); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Remove", _m_Remove); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveAll", _m_RemoveAll); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveAt", _m_RemoveAt); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveRange", _m_RemoveRange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Reverse", _m_Reverse); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Sort", _m_Sort); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToArray", _m_ToArray); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TrimExcess", _m_TrimExcess); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TrueForAll", _m_TrueForAll); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Capacity", _g_get_Capacity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Count", _g_get_Count); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Capacity", _s_set_Capacity); + + + Utils.EndObjectRegister(type, L, translator, __CSIndexer, __NewIndexer, + 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 System.Collections.Generic.List>(); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _capacity = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = new System.Collections.Generic.List>(_capacity); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && translator.Assignable>>(L, 2)) + { + System.Collections.Generic.IEnumerable> _collection = (System.Collections.Generic.IEnumerable>)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEnumerable>)); + + var gen_ret = new System.Collections.Generic.List>(_collection); + 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 System.Collections.Generic.List> constructor!"); + + } + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __CSIndexer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + if (translator.Assignable>>(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + int index = LuaAPI.xlua_tointeger(L, 2); + LuaAPI.lua_pushboolean(L, true); + translator.Push(L, gen_to_be_invoked[index]); + return 2; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __NewIndexer(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + try { + + if (translator.Assignable>>(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && translator.Assignable>(L, 3)) + { + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + int key = LuaAPI.xlua_tointeger(L, 2); + gen_to_be_invoked[key] = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + LuaAPI.lua_pushboolean(L, true); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Add(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.List _item = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.Add( _item ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddRange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.IEnumerable> _collection = (System.Collections.Generic.IEnumerable>)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEnumerable>)); + + gen_to_be_invoked.AddRange( _collection ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AsReadOnly(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.AsReadOnly( ); + 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_BinarySearch(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.List _item = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + var gen_ret = gen_to_be_invoked.BinarySearch( _item ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable>(L, 2)&& translator.Assignable>>(L, 3)) + { + System.Collections.Generic.List _item = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + System.Collections.Generic.IComparer> _comparer = (System.Collections.Generic.IComparer>)translator.GetObject(L, 3, typeof(System.Collections.Generic.IComparer>)); + + var gen_ret = gen_to_be_invoked.BinarySearch( _item, _comparer ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable>(L, 4)&& translator.Assignable>>(L, 5)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + System.Collections.Generic.List _item = (System.Collections.Generic.List)translator.GetObject(L, 4, typeof(System.Collections.Generic.List)); + System.Collections.Generic.IComparer> _comparer = (System.Collections.Generic.IComparer>)translator.GetObject(L, 5, typeof(System.Collections.Generic.IComparer>)); + + var gen_ret = gen_to_be_invoked.BinarySearch( _index, _count, _item, _comparer ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List>.BinarySearch!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Clear(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Clear( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Contains(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.List _item = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + var gen_ret = gen_to_be_invoked.Contains( _item ); + 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_CopyTo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable[]>(L, 2)) + { + System.Collections.Generic.List[] _array = (System.Collections.Generic.List[])translator.GetObject(L, 2, typeof(System.Collections.Generic.List[])); + + gen_to_be_invoked.CopyTo( _array ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable[]>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + System.Collections.Generic.List[] _array = (System.Collections.Generic.List[])translator.GetObject(L, 2, typeof(System.Collections.Generic.List[])); + int _arrayIndex = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.CopyTo( _array, _arrayIndex ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable[]>(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List[] _array = (System.Collections.Generic.List[])translator.GetObject(L, 3, typeof(System.Collections.Generic.List[])); + int _arrayIndex = LuaAPI.xlua_tointeger(L, 4); + int _count = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.CopyTo( _index, _array, _arrayIndex, _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.List>.CopyTo!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Exists(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate> _match = translator.GetDelegate>>(L, 2); + + var gen_ret = gen_to_be_invoked.Exists( _match ); + 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_Find(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate> _match = translator.GetDelegate>>(L, 2); + + var gen_ret = gen_to_be_invoked.Find( _match ); + 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_FindAll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate> _match = translator.GetDelegate>>(L, 2); + + var gen_ret = gen_to_be_invoked.FindAll( _match ); + 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_FindIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>>(L, 2)) + { + System.Predicate> _match = translator.GetDelegate>>(L, 2); + + var gen_ret = gen_to_be_invoked.FindIndex( _match ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>>(L, 3)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + System.Predicate> _match = translator.GetDelegate>>(L, 3); + + var gen_ret = gen_to_be_invoked.FindIndex( _startIndex, _match ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable>>(L, 4)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + System.Predicate> _match = translator.GetDelegate>>(L, 4); + + var gen_ret = gen_to_be_invoked.FindIndex( _startIndex, _count, _match ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List>.FindIndex!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FindLast(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate> _match = translator.GetDelegate>>(L, 2); + + var gen_ret = gen_to_be_invoked.FindLast( _match ); + 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_FindLastIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>>(L, 2)) + { + System.Predicate> _match = translator.GetDelegate>>(L, 2); + + var gen_ret = gen_to_be_invoked.FindLastIndex( _match ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>>(L, 3)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + System.Predicate> _match = translator.GetDelegate>>(L, 3); + + var gen_ret = gen_to_be_invoked.FindLastIndex( _startIndex, _match ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable>>(L, 4)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + System.Predicate> _match = translator.GetDelegate>>(L, 4); + + var gen_ret = gen_to_be_invoked.FindLastIndex( _startIndex, _count, _match ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List>.FindLastIndex!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ForEach(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + + + + { + System.Action> _action = translator.GetDelegate>>(L, 2); + + gen_to_be_invoked.ForEach( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetEnumerator(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetEnumerator( ); + 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_GetRange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.GetRange( _index, _count ); + 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_IndexOf(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.List _item = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + var gen_ret = gen_to_be_invoked.IndexOf( _item ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + System.Collections.Generic.List _item = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _index = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.IndexOf( _item, _index ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + System.Collections.Generic.List _item = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _index = LuaAPI.xlua_tointeger(L, 3); + int _count = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.IndexOf( _item, _index, _count ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List>.IndexOf!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Insert(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _item = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.Insert( _index, _item ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_InsertRange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.IEnumerable> _collection = (System.Collections.Generic.IEnumerable>)translator.GetObject(L, 3, typeof(System.Collections.Generic.IEnumerable>)); + + gen_to_be_invoked.InsertRange( _index, _collection ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LastIndexOf(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.List _item = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + var gen_ret = gen_to_be_invoked.LastIndexOf( _item ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + System.Collections.Generic.List _item = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _index = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.LastIndexOf( _item, _index ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + System.Collections.Generic.List _item = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _index = LuaAPI.xlua_tointeger(L, 3); + int _count = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.LastIndexOf( _item, _index, _count ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List>.LastIndexOf!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Remove(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.List _item = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + var gen_ret = gen_to_be_invoked.Remove( _item ); + 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_RemoveAll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate> _match = translator.GetDelegate>>(L, 2); + + var gen_ret = gen_to_be_invoked.RemoveAll( _match ); + 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_RemoveAt(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.RemoveAt( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveRange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.RemoveRange( _index, _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Reverse(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.Reverse( ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.Reverse( _index, _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.List>.Reverse!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Sort(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.Sort( ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>>(L, 2)) + { + System.Collections.Generic.IComparer> _comparer = (System.Collections.Generic.IComparer>)translator.GetObject(L, 2, typeof(System.Collections.Generic.IComparer>)); + + gen_to_be_invoked.Sort( _comparer ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>>(L, 2)) + { + System.Comparison> _comparison = translator.GetDelegate>>(L, 2); + + gen_to_be_invoked.Sort( _comparison ); + + + + return 0; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable>>(L, 4)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + System.Collections.Generic.IComparer> _comparer = (System.Collections.Generic.IComparer>)translator.GetObject(L, 4, typeof(System.Collections.Generic.IComparer>)); + + gen_to_be_invoked.Sort( _index, _count, _comparer ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.List>.Sort!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToArray(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.ToArray( ); + 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_TrimExcess(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.TrimExcess( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TrueForAll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate> _match = translator.GetDelegate>>(L, 2); + + var gen_ret = gen_to_be_invoked.TrueForAll( _match ); + 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 _g_get_Capacity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Capacity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Count(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Count); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Capacity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Collections.Generic.List> gen_to_be_invoked = (System.Collections.Generic.List>)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Capacity = 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/System_Collections_Generic_List_1_System_Int32_Wrap.cs b/Assets/XLua/Gen/System_Collections_Generic_List_1_System_Int32_Wrap.cs new file mode 100644 index 000000000..76005e5f5 --- /dev/null +++ b/Assets/XLua/Gen/System_Collections_Generic_List_1_System_Int32_Wrap.cs @@ -0,0 +1,1279 @@ +#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 SystemCollectionsGenericList_1_SystemInt32_Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(System.Collections.Generic.List); + Utils.BeginObjectRegister(type, L, translator, 0, 29, 2, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Add", _m_Add); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddRange", _m_AddRange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AsReadOnly", _m_AsReadOnly); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "BinarySearch", _m_BinarySearch); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Contains", _m_Contains); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CopyTo", _m_CopyTo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Exists", _m_Exists); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Find", _m_Find); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindAll", _m_FindAll); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindIndex", _m_FindIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindLast", _m_FindLast); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindLastIndex", _m_FindLastIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ForEach", _m_ForEach); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetEnumerator", _m_GetEnumerator); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetRange", _m_GetRange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IndexOf", _m_IndexOf); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Insert", _m_Insert); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InsertRange", _m_InsertRange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LastIndexOf", _m_LastIndexOf); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Remove", _m_Remove); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveAll", _m_RemoveAll); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveAt", _m_RemoveAt); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveRange", _m_RemoveRange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Reverse", _m_Reverse); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Sort", _m_Sort); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToArray", _m_ToArray); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TrimExcess", _m_TrimExcess); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TrueForAll", _m_TrueForAll); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Capacity", _g_get_Capacity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Count", _g_get_Count); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Capacity", _s_set_Capacity); + + + Utils.EndObjectRegister(type, L, translator, __CSIndexer, __NewIndexer, + 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 System.Collections.Generic.List(); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _capacity = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = new System.Collections.Generic.List(_capacity); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && translator.Assignable>(L, 2)) + { + System.Collections.Generic.IEnumerable _collection = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEnumerable)); + + var gen_ret = new System.Collections.Generic.List(_collection); + 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 System.Collections.Generic.List constructor!"); + + } + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __CSIndexer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + if (translator.Assignable>(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + int index = LuaAPI.xlua_tointeger(L, 2); + LuaAPI.lua_pushboolean(L, true); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked[index]); + return 2; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __NewIndexer(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + try { + + if (translator.Assignable>(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + int key = LuaAPI.xlua_tointeger(L, 2); + gen_to_be_invoked[key] = LuaAPI.xlua_tointeger(L, 3); + LuaAPI.lua_pushboolean(L, true); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Add(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _item = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.Add( _item ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddRange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.IEnumerable _collection = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEnumerable)); + + gen_to_be_invoked.AddRange( _collection ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AsReadOnly(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.AsReadOnly( ); + 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_BinarySearch(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _item = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.BinarySearch( _item ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _item = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.IComparer _comparer = (System.Collections.Generic.IComparer)translator.GetObject(L, 3, typeof(System.Collections.Generic.IComparer)); + + var gen_ret = gen_to_be_invoked.BinarySearch( _item, _comparer ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable>(L, 5)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + int _item = LuaAPI.xlua_tointeger(L, 4); + System.Collections.Generic.IComparer _comparer = (System.Collections.Generic.IComparer)translator.GetObject(L, 5, typeof(System.Collections.Generic.IComparer)); + + var gen_ret = gen_to_be_invoked.BinarySearch( _index, _count, _item, _comparer ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.BinarySearch!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Clear(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Clear( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Contains(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _item = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.Contains( _item ); + 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_CopyTo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + int[] _array = (int[])translator.GetObject(L, 2, typeof(int[])); + + gen_to_be_invoked.CopyTo( _array ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int[] _array = (int[])translator.GetObject(L, 2, typeof(int[])); + int _arrayIndex = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.CopyTo( _array, _arrayIndex ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int[] _array = (int[])translator.GetObject(L, 3, typeof(int[])); + int _arrayIndex = LuaAPI.xlua_tointeger(L, 4); + int _count = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.CopyTo( _index, _array, _arrayIndex, _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.List.CopyTo!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Exists(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.Exists( _match ); + 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_Find(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.Find( _match ); + 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_FindAll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.FindAll( _match ); + 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_FindIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.FindIndex( _match ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + System.Predicate _match = translator.GetDelegate>(L, 3); + + var gen_ret = gen_to_be_invoked.FindIndex( _startIndex, _match ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable>(L, 4)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + System.Predicate _match = translator.GetDelegate>(L, 4); + + var gen_ret = gen_to_be_invoked.FindIndex( _startIndex, _count, _match ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.FindIndex!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FindLast(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.FindLast( _match ); + 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_FindLastIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.FindLastIndex( _match ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + System.Predicate _match = translator.GetDelegate>(L, 3); + + var gen_ret = gen_to_be_invoked.FindLastIndex( _startIndex, _match ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable>(L, 4)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + System.Predicate _match = translator.GetDelegate>(L, 4); + + var gen_ret = gen_to_be_invoked.FindLastIndex( _startIndex, _count, _match ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.FindLastIndex!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ForEach(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.ForEach( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetEnumerator(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetEnumerator( ); + 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_GetRange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.GetRange( _index, _count ); + 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_IndexOf(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _item = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.IndexOf( _item ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _item = LuaAPI.xlua_tointeger(L, 2); + int _index = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.IndexOf( _item, _index ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + int _item = LuaAPI.xlua_tointeger(L, 2); + int _index = LuaAPI.xlua_tointeger(L, 3); + int _count = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.IndexOf( _item, _index, _count ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.IndexOf!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Insert(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _item = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.Insert( _index, _item ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_InsertRange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.IEnumerable _collection = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 3, typeof(System.Collections.Generic.IEnumerable)); + + gen_to_be_invoked.InsertRange( _index, _collection ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LastIndexOf(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _item = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.LastIndexOf( _item ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _item = LuaAPI.xlua_tointeger(L, 2); + int _index = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.LastIndexOf( _item, _index ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + int _item = LuaAPI.xlua_tointeger(L, 2); + int _index = LuaAPI.xlua_tointeger(L, 3); + int _count = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.LastIndexOf( _item, _index, _count ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.LastIndexOf!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Remove(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _item = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.Remove( _item ); + 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_RemoveAll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.RemoveAll( _match ); + 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_RemoveAt(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.RemoveAt( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveRange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.RemoveRange( _index, _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Reverse(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.Reverse( ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.Reverse( _index, _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.List.Reverse!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Sort(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.Sort( ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.IComparer _comparer = (System.Collections.Generic.IComparer)translator.GetObject(L, 2, typeof(System.Collections.Generic.IComparer)); + + gen_to_be_invoked.Sort( _comparer ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Comparison _comparison = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.Sort( _comparison ); + + + + return 0; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable>(L, 4)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + System.Collections.Generic.IComparer _comparer = (System.Collections.Generic.IComparer)translator.GetObject(L, 4, typeof(System.Collections.Generic.IComparer)); + + gen_to_be_invoked.Sort( _index, _count, _comparer ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.List.Sort!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToArray(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.ToArray( ); + 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_TrimExcess(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.TrimExcess( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TrueForAll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.TrueForAll( _match ); + 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 _g_get_Capacity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Capacity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Count(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Count); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Capacity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Capacity = 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/System_Collections_Generic_List_1_System_Single_Wrap.cs b/Assets/XLua/Gen/System_Collections_Generic_List_1_System_Single_Wrap.cs new file mode 100644 index 000000000..5af45d8e0 --- /dev/null +++ b/Assets/XLua/Gen/System_Collections_Generic_List_1_System_Single_Wrap.cs @@ -0,0 +1,1279 @@ +#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 SystemCollectionsGenericList_1_SystemSingle_Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(System.Collections.Generic.List); + Utils.BeginObjectRegister(type, L, translator, 0, 29, 2, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Add", _m_Add); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddRange", _m_AddRange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AsReadOnly", _m_AsReadOnly); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "BinarySearch", _m_BinarySearch); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Contains", _m_Contains); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CopyTo", _m_CopyTo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Exists", _m_Exists); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Find", _m_Find); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindAll", _m_FindAll); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindIndex", _m_FindIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindLast", _m_FindLast); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindLastIndex", _m_FindLastIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ForEach", _m_ForEach); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetEnumerator", _m_GetEnumerator); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetRange", _m_GetRange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IndexOf", _m_IndexOf); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Insert", _m_Insert); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InsertRange", _m_InsertRange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LastIndexOf", _m_LastIndexOf); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Remove", _m_Remove); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveAll", _m_RemoveAll); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveAt", _m_RemoveAt); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveRange", _m_RemoveRange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Reverse", _m_Reverse); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Sort", _m_Sort); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToArray", _m_ToArray); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TrimExcess", _m_TrimExcess); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TrueForAll", _m_TrueForAll); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Capacity", _g_get_Capacity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Count", _g_get_Count); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Capacity", _s_set_Capacity); + + + Utils.EndObjectRegister(type, L, translator, __CSIndexer, __NewIndexer, + 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 System.Collections.Generic.List(); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _capacity = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = new System.Collections.Generic.List(_capacity); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && translator.Assignable>(L, 2)) + { + System.Collections.Generic.IEnumerable _collection = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEnumerable)); + + var gen_ret = new System.Collections.Generic.List(_collection); + 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 System.Collections.Generic.List constructor!"); + + } + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __CSIndexer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + if (translator.Assignable>(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + int index = LuaAPI.xlua_tointeger(L, 2); + LuaAPI.lua_pushboolean(L, true); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked[index]); + return 2; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __NewIndexer(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + try { + + if (translator.Assignable>(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + int key = LuaAPI.xlua_tointeger(L, 2); + gen_to_be_invoked[key] = (float)LuaAPI.lua_tonumber(L, 3); + LuaAPI.lua_pushboolean(L, true); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Add(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + float _item = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.Add( _item ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddRange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.IEnumerable _collection = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEnumerable)); + + gen_to_be_invoked.AddRange( _collection ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AsReadOnly(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.AsReadOnly( ); + 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_BinarySearch(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _item = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.BinarySearch( _item ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + float _item = (float)LuaAPI.lua_tonumber(L, 2); + System.Collections.Generic.IComparer _comparer = (System.Collections.Generic.IComparer)translator.GetObject(L, 3, typeof(System.Collections.Generic.IComparer)); + + var gen_ret = gen_to_be_invoked.BinarySearch( _item, _comparer ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable>(L, 5)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + float _item = (float)LuaAPI.lua_tonumber(L, 4); + System.Collections.Generic.IComparer _comparer = (System.Collections.Generic.IComparer)translator.GetObject(L, 5, typeof(System.Collections.Generic.IComparer)); + + var gen_ret = gen_to_be_invoked.BinarySearch( _index, _count, _item, _comparer ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.BinarySearch!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Clear(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Clear( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Contains(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + float _item = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.Contains( _item ); + 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_CopyTo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + float[] _array = (float[])translator.GetObject(L, 2, typeof(float[])); + + gen_to_be_invoked.CopyTo( _array ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float[] _array = (float[])translator.GetObject(L, 2, typeof(float[])); + int _arrayIndex = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.CopyTo( _array, _arrayIndex ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float[] _array = (float[])translator.GetObject(L, 3, typeof(float[])); + int _arrayIndex = LuaAPI.xlua_tointeger(L, 4); + int _count = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.CopyTo( _index, _array, _arrayIndex, _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.List.CopyTo!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Exists(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.Exists( _match ); + 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_Find(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.Find( _match ); + LuaAPI.lua_pushnumber(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_FindAll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.FindAll( _match ); + 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_FindIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.FindIndex( _match ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + System.Predicate _match = translator.GetDelegate>(L, 3); + + var gen_ret = gen_to_be_invoked.FindIndex( _startIndex, _match ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable>(L, 4)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + System.Predicate _match = translator.GetDelegate>(L, 4); + + var gen_ret = gen_to_be_invoked.FindIndex( _startIndex, _count, _match ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.FindIndex!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FindLast(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.FindLast( _match ); + LuaAPI.lua_pushnumber(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_FindLastIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.FindLastIndex( _match ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + System.Predicate _match = translator.GetDelegate>(L, 3); + + var gen_ret = gen_to_be_invoked.FindLastIndex( _startIndex, _match ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable>(L, 4)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + System.Predicate _match = translator.GetDelegate>(L, 4); + + var gen_ret = gen_to_be_invoked.FindLastIndex( _startIndex, _count, _match ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.FindLastIndex!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ForEach(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.ForEach( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetEnumerator(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetEnumerator( ); + 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_GetRange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.GetRange( _index, _count ); + 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_IndexOf(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _item = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.IndexOf( _item ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _item = (float)LuaAPI.lua_tonumber(L, 2); + int _index = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.IndexOf( _item, _index ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _item = (float)LuaAPI.lua_tonumber(L, 2); + int _index = LuaAPI.xlua_tointeger(L, 3); + int _count = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.IndexOf( _item, _index, _count ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.IndexOf!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Insert(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _item = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.Insert( _index, _item ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_InsertRange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.IEnumerable _collection = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 3, typeof(System.Collections.Generic.IEnumerable)); + + gen_to_be_invoked.InsertRange( _index, _collection ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LastIndexOf(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _item = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.LastIndexOf( _item ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _item = (float)LuaAPI.lua_tonumber(L, 2); + int _index = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.LastIndexOf( _item, _index ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _item = (float)LuaAPI.lua_tonumber(L, 2); + int _index = LuaAPI.xlua_tointeger(L, 3); + int _count = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.LastIndexOf( _item, _index, _count ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.LastIndexOf!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Remove(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + float _item = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.Remove( _item ); + 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_RemoveAll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.RemoveAll( _match ); + 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_RemoveAt(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.RemoveAt( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveRange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.RemoveRange( _index, _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Reverse(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.Reverse( ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.Reverse( _index, _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.List.Reverse!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Sort(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.Sort( ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.IComparer _comparer = (System.Collections.Generic.IComparer)translator.GetObject(L, 2, typeof(System.Collections.Generic.IComparer)); + + gen_to_be_invoked.Sort( _comparer ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Comparison _comparison = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.Sort( _comparison ); + + + + return 0; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable>(L, 4)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + System.Collections.Generic.IComparer _comparer = (System.Collections.Generic.IComparer)translator.GetObject(L, 4, typeof(System.Collections.Generic.IComparer)); + + gen_to_be_invoked.Sort( _index, _count, _comparer ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.List.Sort!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToArray(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.ToArray( ); + 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_TrimExcess(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.TrimExcess( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TrueForAll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.TrueForAll( _match ); + 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 _g_get_Capacity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Capacity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Count(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Count); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Capacity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Capacity = 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/System_Collections_Generic_List_1_System_String_Wrap.cs b/Assets/XLua/Gen/System_Collections_Generic_List_1_System_String_Wrap.cs new file mode 100644 index 000000000..0cead63c9 --- /dev/null +++ b/Assets/XLua/Gen/System_Collections_Generic_List_1_System_String_Wrap.cs @@ -0,0 +1,1279 @@ +#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 SystemCollectionsGenericList_1_SystemString_Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(System.Collections.Generic.List); + Utils.BeginObjectRegister(type, L, translator, 0, 29, 2, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Add", _m_Add); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddRange", _m_AddRange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AsReadOnly", _m_AsReadOnly); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "BinarySearch", _m_BinarySearch); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Contains", _m_Contains); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CopyTo", _m_CopyTo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Exists", _m_Exists); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Find", _m_Find); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindAll", _m_FindAll); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindIndex", _m_FindIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindLast", _m_FindLast); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindLastIndex", _m_FindLastIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ForEach", _m_ForEach); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetEnumerator", _m_GetEnumerator); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetRange", _m_GetRange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IndexOf", _m_IndexOf); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Insert", _m_Insert); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InsertRange", _m_InsertRange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LastIndexOf", _m_LastIndexOf); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Remove", _m_Remove); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveAll", _m_RemoveAll); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveAt", _m_RemoveAt); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveRange", _m_RemoveRange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Reverse", _m_Reverse); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Sort", _m_Sort); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToArray", _m_ToArray); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TrimExcess", _m_TrimExcess); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TrueForAll", _m_TrueForAll); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Capacity", _g_get_Capacity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Count", _g_get_Count); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Capacity", _s_set_Capacity); + + + Utils.EndObjectRegister(type, L, translator, __CSIndexer, __NewIndexer, + 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 System.Collections.Generic.List(); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _capacity = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = new System.Collections.Generic.List(_capacity); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && translator.Assignable>(L, 2)) + { + System.Collections.Generic.IEnumerable _collection = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEnumerable)); + + var gen_ret = new System.Collections.Generic.List(_collection); + 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 System.Collections.Generic.List constructor!"); + + } + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __CSIndexer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + if (translator.Assignable>(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + int index = LuaAPI.xlua_tointeger(L, 2); + LuaAPI.lua_pushboolean(L, true); + LuaAPI.lua_pushstring(L, gen_to_be_invoked[index]); + return 2; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __NewIndexer(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + try { + + if (translator.Assignable>(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + int key = LuaAPI.xlua_tointeger(L, 2); + gen_to_be_invoked[key] = LuaAPI.lua_tostring(L, 3); + LuaAPI.lua_pushboolean(L, true); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Add(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + string _item = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.Add( _item ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddRange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.IEnumerable _collection = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEnumerable)); + + gen_to_be_invoked.AddRange( _collection ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AsReadOnly(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.AsReadOnly( ); + 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_BinarySearch(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _item = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.BinarySearch( _item ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 3)) + { + string _item = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.IComparer _comparer = (System.Collections.Generic.IComparer)translator.GetObject(L, 3, typeof(System.Collections.Generic.IComparer)); + + var gen_ret = gen_to_be_invoked.BinarySearch( _item, _comparer ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 5)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + string _item = LuaAPI.lua_tostring(L, 4); + System.Collections.Generic.IComparer _comparer = (System.Collections.Generic.IComparer)translator.GetObject(L, 5, typeof(System.Collections.Generic.IComparer)); + + var gen_ret = gen_to_be_invoked.BinarySearch( _index, _count, _item, _comparer ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.BinarySearch!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Clear(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Clear( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Contains(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + string _item = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.Contains( _item ); + 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_CopyTo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + string[] _array = (string[])translator.GetObject(L, 2, typeof(string[])); + + gen_to_be_invoked.CopyTo( _array ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + string[] _array = (string[])translator.GetObject(L, 2, typeof(string[])); + int _arrayIndex = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.CopyTo( _array, _arrayIndex ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + string[] _array = (string[])translator.GetObject(L, 3, typeof(string[])); + int _arrayIndex = LuaAPI.xlua_tointeger(L, 4); + int _count = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.CopyTo( _index, _array, _arrayIndex, _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.List.CopyTo!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Exists(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.Exists( _match ); + 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_Find(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.Find( _match ); + 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 _m_FindAll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.FindAll( _match ); + 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_FindIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.FindIndex( _match ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + System.Predicate _match = translator.GetDelegate>(L, 3); + + var gen_ret = gen_to_be_invoked.FindIndex( _startIndex, _match ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable>(L, 4)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + System.Predicate _match = translator.GetDelegate>(L, 4); + + var gen_ret = gen_to_be_invoked.FindIndex( _startIndex, _count, _match ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.FindIndex!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FindLast(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.FindLast( _match ); + 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 _m_FindLastIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.FindLastIndex( _match ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + System.Predicate _match = translator.GetDelegate>(L, 3); + + var gen_ret = gen_to_be_invoked.FindLastIndex( _startIndex, _match ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable>(L, 4)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + System.Predicate _match = translator.GetDelegate>(L, 4); + + var gen_ret = gen_to_be_invoked.FindLastIndex( _startIndex, _count, _match ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.FindLastIndex!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ForEach(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.ForEach( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetEnumerator(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetEnumerator( ); + 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_GetRange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.GetRange( _index, _count ); + 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_IndexOf(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _item = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.IndexOf( _item ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + string _item = LuaAPI.lua_tostring(L, 2); + int _index = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.IndexOf( _item, _index ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + string _item = LuaAPI.lua_tostring(L, 2); + int _index = LuaAPI.xlua_tointeger(L, 3); + int _count = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.IndexOf( _item, _index, _count ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.IndexOf!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Insert(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + string _item = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.Insert( _index, _item ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_InsertRange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.IEnumerable _collection = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 3, typeof(System.Collections.Generic.IEnumerable)); + + gen_to_be_invoked.InsertRange( _index, _collection ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LastIndexOf(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _item = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.LastIndexOf( _item ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + string _item = LuaAPI.lua_tostring(L, 2); + int _index = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.LastIndexOf( _item, _index ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + string _item = LuaAPI.lua_tostring(L, 2); + int _index = LuaAPI.xlua_tointeger(L, 3); + int _count = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.LastIndexOf( _item, _index, _count ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.LastIndexOf!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Remove(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + string _item = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.Remove( _item ); + 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_RemoveAll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.RemoveAll( _match ); + 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_RemoveAt(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.RemoveAt( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveRange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.RemoveRange( _index, _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Reverse(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.Reverse( ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.Reverse( _index, _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.List.Reverse!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Sort(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.Sort( ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.IComparer _comparer = (System.Collections.Generic.IComparer)translator.GetObject(L, 2, typeof(System.Collections.Generic.IComparer)); + + gen_to_be_invoked.Sort( _comparer ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Comparison _comparison = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.Sort( _comparison ); + + + + return 0; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable>(L, 4)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + System.Collections.Generic.IComparer _comparer = (System.Collections.Generic.IComparer)translator.GetObject(L, 4, typeof(System.Collections.Generic.IComparer)); + + gen_to_be_invoked.Sort( _index, _count, _comparer ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.List.Sort!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToArray(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.ToArray( ); + 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_TrimExcess(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.TrimExcess( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TrueForAll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.TrueForAll( _match ); + 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 _g_get_Capacity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Capacity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Count(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Count); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Capacity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Capacity = 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/System_Collections_Generic_List_1_TMPro_TMP_FontAsset_Wrap.cs b/Assets/XLua/Gen/System_Collections_Generic_List_1_TMPro_TMP_FontAsset_Wrap.cs new file mode 100644 index 000000000..02406a6f7 --- /dev/null +++ b/Assets/XLua/Gen/System_Collections_Generic_List_1_TMPro_TMP_FontAsset_Wrap.cs @@ -0,0 +1,1279 @@ +#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 SystemCollectionsGenericList_1_TMProTMP_FontAsset_Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(System.Collections.Generic.List); + Utils.BeginObjectRegister(type, L, translator, 0, 29, 2, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Add", _m_Add); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddRange", _m_AddRange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AsReadOnly", _m_AsReadOnly); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "BinarySearch", _m_BinarySearch); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Contains", _m_Contains); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CopyTo", _m_CopyTo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Exists", _m_Exists); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Find", _m_Find); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindAll", _m_FindAll); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindIndex", _m_FindIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindLast", _m_FindLast); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindLastIndex", _m_FindLastIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ForEach", _m_ForEach); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetEnumerator", _m_GetEnumerator); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetRange", _m_GetRange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IndexOf", _m_IndexOf); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Insert", _m_Insert); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InsertRange", _m_InsertRange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LastIndexOf", _m_LastIndexOf); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Remove", _m_Remove); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveAll", _m_RemoveAll); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveAt", _m_RemoveAt); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveRange", _m_RemoveRange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Reverse", _m_Reverse); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Sort", _m_Sort); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToArray", _m_ToArray); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TrimExcess", _m_TrimExcess); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TrueForAll", _m_TrueForAll); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Capacity", _g_get_Capacity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Count", _g_get_Count); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Capacity", _s_set_Capacity); + + + Utils.EndObjectRegister(type, L, translator, __CSIndexer, __NewIndexer, + 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 System.Collections.Generic.List(); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _capacity = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = new System.Collections.Generic.List(_capacity); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && translator.Assignable>(L, 2)) + { + System.Collections.Generic.IEnumerable _collection = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEnumerable)); + + var gen_ret = new System.Collections.Generic.List(_collection); + 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 System.Collections.Generic.List constructor!"); + + } + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __CSIndexer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + if (translator.Assignable>(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + int index = LuaAPI.xlua_tointeger(L, 2); + LuaAPI.lua_pushboolean(L, true); + translator.Push(L, gen_to_be_invoked[index]); + return 2; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __NewIndexer(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + try { + + if (translator.Assignable>(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && translator.Assignable(L, 3)) + { + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + int key = LuaAPI.xlua_tointeger(L, 2); + gen_to_be_invoked[key] = (TMPro.TMP_FontAsset)translator.GetObject(L, 3, typeof(TMPro.TMP_FontAsset)); + LuaAPI.lua_pushboolean(L, true); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Add(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + TMPro.TMP_FontAsset _item = (TMPro.TMP_FontAsset)translator.GetObject(L, 2, typeof(TMPro.TMP_FontAsset)); + + gen_to_be_invoked.Add( _item ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddRange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.IEnumerable _collection = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEnumerable)); + + gen_to_be_invoked.AddRange( _collection ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AsReadOnly(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.AsReadOnly( ); + 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_BinarySearch(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + TMPro.TMP_FontAsset _item = (TMPro.TMP_FontAsset)translator.GetObject(L, 2, typeof(TMPro.TMP_FontAsset)); + + var gen_ret = gen_to_be_invoked.BinarySearch( _item ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable>(L, 3)) + { + TMPro.TMP_FontAsset _item = (TMPro.TMP_FontAsset)translator.GetObject(L, 2, typeof(TMPro.TMP_FontAsset)); + System.Collections.Generic.IComparer _comparer = (System.Collections.Generic.IComparer)translator.GetObject(L, 3, typeof(System.Collections.Generic.IComparer)); + + var gen_ret = gen_to_be_invoked.BinarySearch( _item, _comparer ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable>(L, 5)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + TMPro.TMP_FontAsset _item = (TMPro.TMP_FontAsset)translator.GetObject(L, 4, typeof(TMPro.TMP_FontAsset)); + System.Collections.Generic.IComparer _comparer = (System.Collections.Generic.IComparer)translator.GetObject(L, 5, typeof(System.Collections.Generic.IComparer)); + + var gen_ret = gen_to_be_invoked.BinarySearch( _index, _count, _item, _comparer ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.BinarySearch!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Clear(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Clear( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Contains(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + TMPro.TMP_FontAsset _item = (TMPro.TMP_FontAsset)translator.GetObject(L, 2, typeof(TMPro.TMP_FontAsset)); + + var gen_ret = gen_to_be_invoked.Contains( _item ); + 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_CopyTo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + TMPro.TMP_FontAsset[] _array = (TMPro.TMP_FontAsset[])translator.GetObject(L, 2, typeof(TMPro.TMP_FontAsset[])); + + gen_to_be_invoked.CopyTo( _array ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + TMPro.TMP_FontAsset[] _array = (TMPro.TMP_FontAsset[])translator.GetObject(L, 2, typeof(TMPro.TMP_FontAsset[])); + int _arrayIndex = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.CopyTo( _array, _arrayIndex ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + TMPro.TMP_FontAsset[] _array = (TMPro.TMP_FontAsset[])translator.GetObject(L, 3, typeof(TMPro.TMP_FontAsset[])); + int _arrayIndex = LuaAPI.xlua_tointeger(L, 4); + int _count = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.CopyTo( _index, _array, _arrayIndex, _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.List.CopyTo!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Exists(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.Exists( _match ); + 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_Find(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.Find( _match ); + 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_FindAll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.FindAll( _match ); + 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_FindIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.FindIndex( _match ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + System.Predicate _match = translator.GetDelegate>(L, 3); + + var gen_ret = gen_to_be_invoked.FindIndex( _startIndex, _match ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable>(L, 4)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + System.Predicate _match = translator.GetDelegate>(L, 4); + + var gen_ret = gen_to_be_invoked.FindIndex( _startIndex, _count, _match ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.FindIndex!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FindLast(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.FindLast( _match ); + 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_FindLastIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.FindLastIndex( _match ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + System.Predicate _match = translator.GetDelegate>(L, 3); + + var gen_ret = gen_to_be_invoked.FindLastIndex( _startIndex, _match ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable>(L, 4)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + System.Predicate _match = translator.GetDelegate>(L, 4); + + var gen_ret = gen_to_be_invoked.FindLastIndex( _startIndex, _count, _match ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.FindLastIndex!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ForEach(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.ForEach( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetEnumerator(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetEnumerator( ); + 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_GetRange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.GetRange( _index, _count ); + 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_IndexOf(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + TMPro.TMP_FontAsset _item = (TMPro.TMP_FontAsset)translator.GetObject(L, 2, typeof(TMPro.TMP_FontAsset)); + + var gen_ret = gen_to_be_invoked.IndexOf( _item ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + TMPro.TMP_FontAsset _item = (TMPro.TMP_FontAsset)translator.GetObject(L, 2, typeof(TMPro.TMP_FontAsset)); + int _index = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.IndexOf( _item, _index ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + TMPro.TMP_FontAsset _item = (TMPro.TMP_FontAsset)translator.GetObject(L, 2, typeof(TMPro.TMP_FontAsset)); + int _index = LuaAPI.xlua_tointeger(L, 3); + int _count = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.IndexOf( _item, _index, _count ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.IndexOf!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Insert(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + TMPro.TMP_FontAsset _item = (TMPro.TMP_FontAsset)translator.GetObject(L, 3, typeof(TMPro.TMP_FontAsset)); + + gen_to_be_invoked.Insert( _index, _item ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_InsertRange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.IEnumerable _collection = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 3, typeof(System.Collections.Generic.IEnumerable)); + + gen_to_be_invoked.InsertRange( _index, _collection ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LastIndexOf(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + TMPro.TMP_FontAsset _item = (TMPro.TMP_FontAsset)translator.GetObject(L, 2, typeof(TMPro.TMP_FontAsset)); + + var gen_ret = gen_to_be_invoked.LastIndexOf( _item ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + TMPro.TMP_FontAsset _item = (TMPro.TMP_FontAsset)translator.GetObject(L, 2, typeof(TMPro.TMP_FontAsset)); + int _index = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.LastIndexOf( _item, _index ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + TMPro.TMP_FontAsset _item = (TMPro.TMP_FontAsset)translator.GetObject(L, 2, typeof(TMPro.TMP_FontAsset)); + int _index = LuaAPI.xlua_tointeger(L, 3); + int _count = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.LastIndexOf( _item, _index, _count ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.LastIndexOf!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Remove(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + TMPro.TMP_FontAsset _item = (TMPro.TMP_FontAsset)translator.GetObject(L, 2, typeof(TMPro.TMP_FontAsset)); + + var gen_ret = gen_to_be_invoked.Remove( _item ); + 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_RemoveAll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.RemoveAll( _match ); + 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_RemoveAt(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.RemoveAt( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveRange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.RemoveRange( _index, _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Reverse(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.Reverse( ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.Reverse( _index, _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.List.Reverse!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Sort(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.Sort( ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.IComparer _comparer = (System.Collections.Generic.IComparer)translator.GetObject(L, 2, typeof(System.Collections.Generic.IComparer)); + + gen_to_be_invoked.Sort( _comparer ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Comparison _comparison = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.Sort( _comparison ); + + + + return 0; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable>(L, 4)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + System.Collections.Generic.IComparer _comparer = (System.Collections.Generic.IComparer)translator.GetObject(L, 4, typeof(System.Collections.Generic.IComparer)); + + gen_to_be_invoked.Sort( _index, _count, _comparer ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.List.Sort!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToArray(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.ToArray( ); + 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_TrimExcess(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.TrimExcess( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TrueForAll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.TrueForAll( _match ); + 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 _g_get_Capacity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Capacity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Count(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Count); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Capacity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Capacity = 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/System_Collections_Generic_List_1_UnityEngine_Camera_Wrap.cs b/Assets/XLua/Gen/System_Collections_Generic_List_1_UnityEngine_Camera_Wrap.cs new file mode 100644 index 000000000..f52a82040 --- /dev/null +++ b/Assets/XLua/Gen/System_Collections_Generic_List_1_UnityEngine_Camera_Wrap.cs @@ -0,0 +1,1279 @@ +#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 SystemCollectionsGenericList_1_UnityEngineCamera_Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(System.Collections.Generic.List); + Utils.BeginObjectRegister(type, L, translator, 0, 29, 2, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Add", _m_Add); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddRange", _m_AddRange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AsReadOnly", _m_AsReadOnly); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "BinarySearch", _m_BinarySearch); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Contains", _m_Contains); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CopyTo", _m_CopyTo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Exists", _m_Exists); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Find", _m_Find); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindAll", _m_FindAll); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindIndex", _m_FindIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindLast", _m_FindLast); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindLastIndex", _m_FindLastIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ForEach", _m_ForEach); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetEnumerator", _m_GetEnumerator); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetRange", _m_GetRange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IndexOf", _m_IndexOf); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Insert", _m_Insert); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InsertRange", _m_InsertRange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LastIndexOf", _m_LastIndexOf); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Remove", _m_Remove); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveAll", _m_RemoveAll); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveAt", _m_RemoveAt); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveRange", _m_RemoveRange); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Reverse", _m_Reverse); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Sort", _m_Sort); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToArray", _m_ToArray); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TrimExcess", _m_TrimExcess); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TrueForAll", _m_TrueForAll); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Capacity", _g_get_Capacity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Count", _g_get_Count); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Capacity", _s_set_Capacity); + + + Utils.EndObjectRegister(type, L, translator, __CSIndexer, __NewIndexer, + 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 System.Collections.Generic.List(); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _capacity = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = new System.Collections.Generic.List(_capacity); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && translator.Assignable>(L, 2)) + { + System.Collections.Generic.IEnumerable _collection = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEnumerable)); + + var gen_ret = new System.Collections.Generic.List(_collection); + 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 System.Collections.Generic.List constructor!"); + + } + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __CSIndexer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + if (translator.Assignable>(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + int index = LuaAPI.xlua_tointeger(L, 2); + LuaAPI.lua_pushboolean(L, true); + translator.Push(L, gen_to_be_invoked[index]); + return 2; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __NewIndexer(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + try { + + if (translator.Assignable>(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && translator.Assignable(L, 3)) + { + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + int key = LuaAPI.xlua_tointeger(L, 2); + gen_to_be_invoked[key] = (UnityEngine.Camera)translator.GetObject(L, 3, typeof(UnityEngine.Camera)); + LuaAPI.lua_pushboolean(L, true); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Add(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Camera _item = (UnityEngine.Camera)translator.GetObject(L, 2, typeof(UnityEngine.Camera)); + + gen_to_be_invoked.Add( _item ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddRange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.IEnumerable _collection = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEnumerable)); + + gen_to_be_invoked.AddRange( _collection ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AsReadOnly(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.AsReadOnly( ); + 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_BinarySearch(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Camera _item = (UnityEngine.Camera)translator.GetObject(L, 2, typeof(UnityEngine.Camera)); + + var gen_ret = gen_to_be_invoked.BinarySearch( _item ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable>(L, 3)) + { + UnityEngine.Camera _item = (UnityEngine.Camera)translator.GetObject(L, 2, typeof(UnityEngine.Camera)); + System.Collections.Generic.IComparer _comparer = (System.Collections.Generic.IComparer)translator.GetObject(L, 3, typeof(System.Collections.Generic.IComparer)); + + var gen_ret = gen_to_be_invoked.BinarySearch( _item, _comparer ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable>(L, 5)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.Camera _item = (UnityEngine.Camera)translator.GetObject(L, 4, typeof(UnityEngine.Camera)); + System.Collections.Generic.IComparer _comparer = (System.Collections.Generic.IComparer)translator.GetObject(L, 5, typeof(System.Collections.Generic.IComparer)); + + var gen_ret = gen_to_be_invoked.BinarySearch( _index, _count, _item, _comparer ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.BinarySearch!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Clear(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Clear( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Contains(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Camera _item = (UnityEngine.Camera)translator.GetObject(L, 2, typeof(UnityEngine.Camera)); + + var gen_ret = gen_to_be_invoked.Contains( _item ); + 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_CopyTo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Camera[] _array = (UnityEngine.Camera[])translator.GetObject(L, 2, typeof(UnityEngine.Camera[])); + + gen_to_be_invoked.CopyTo( _array ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Camera[] _array = (UnityEngine.Camera[])translator.GetObject(L, 2, typeof(UnityEngine.Camera[])); + int _arrayIndex = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.CopyTo( _array, _arrayIndex ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Camera[] _array = (UnityEngine.Camera[])translator.GetObject(L, 3, typeof(UnityEngine.Camera[])); + int _arrayIndex = LuaAPI.xlua_tointeger(L, 4); + int _count = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.CopyTo( _index, _array, _arrayIndex, _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.List.CopyTo!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Exists(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.Exists( _match ); + 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_Find(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.Find( _match ); + 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_FindAll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.FindAll( _match ); + 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_FindIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.FindIndex( _match ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + System.Predicate _match = translator.GetDelegate>(L, 3); + + var gen_ret = gen_to_be_invoked.FindIndex( _startIndex, _match ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable>(L, 4)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + System.Predicate _match = translator.GetDelegate>(L, 4); + + var gen_ret = gen_to_be_invoked.FindIndex( _startIndex, _count, _match ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.FindIndex!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FindLast(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.FindLast( _match ); + 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_FindLastIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.FindLastIndex( _match ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + System.Predicate _match = translator.GetDelegate>(L, 3); + + var gen_ret = gen_to_be_invoked.FindLastIndex( _startIndex, _match ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable>(L, 4)) + { + int _startIndex = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + System.Predicate _match = translator.GetDelegate>(L, 4); + + var gen_ret = gen_to_be_invoked.FindLastIndex( _startIndex, _count, _match ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.FindLastIndex!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ForEach(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Action _action = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.ForEach( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetEnumerator(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetEnumerator( ); + 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_GetRange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.GetRange( _index, _count ); + 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_IndexOf(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Camera _item = (UnityEngine.Camera)translator.GetObject(L, 2, typeof(UnityEngine.Camera)); + + var gen_ret = gen_to_be_invoked.IndexOf( _item ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Camera _item = (UnityEngine.Camera)translator.GetObject(L, 2, typeof(UnityEngine.Camera)); + int _index = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.IndexOf( _item, _index ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Camera _item = (UnityEngine.Camera)translator.GetObject(L, 2, typeof(UnityEngine.Camera)); + int _index = LuaAPI.xlua_tointeger(L, 3); + int _count = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.IndexOf( _item, _index, _count ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.IndexOf!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Insert(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Camera _item = (UnityEngine.Camera)translator.GetObject(L, 3, typeof(UnityEngine.Camera)); + + gen_to_be_invoked.Insert( _index, _item ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_InsertRange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.IEnumerable _collection = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 3, typeof(System.Collections.Generic.IEnumerable)); + + gen_to_be_invoked.InsertRange( _index, _collection ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LastIndexOf(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Camera _item = (UnityEngine.Camera)translator.GetObject(L, 2, typeof(UnityEngine.Camera)); + + var gen_ret = gen_to_be_invoked.LastIndexOf( _item ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Camera _item = (UnityEngine.Camera)translator.GetObject(L, 2, typeof(UnityEngine.Camera)); + int _index = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.LastIndexOf( _item, _index ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Camera _item = (UnityEngine.Camera)translator.GetObject(L, 2, typeof(UnityEngine.Camera)); + int _index = LuaAPI.xlua_tointeger(L, 3); + int _count = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.LastIndexOf( _item, _index, _count ); + LuaAPI.xlua_pushinteger(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 System.Collections.Generic.List.LastIndexOf!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Remove(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Camera _item = (UnityEngine.Camera)translator.GetObject(L, 2, typeof(UnityEngine.Camera)); + + var gen_ret = gen_to_be_invoked.Remove( _item ); + 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_RemoveAll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.RemoveAll( _match ); + 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_RemoveAt(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.RemoveAt( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveRange(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.RemoveRange( _index, _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Reverse(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.Reverse( ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.Reverse( _index, _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.List.Reverse!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Sort(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.Sort( ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.IComparer _comparer = (System.Collections.Generic.IComparer)translator.GetObject(L, 2, typeof(System.Collections.Generic.IComparer)); + + gen_to_be_invoked.Sort( _comparer ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Comparison _comparison = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.Sort( _comparison ); + + + + return 0; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable>(L, 4)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + int _count = LuaAPI.xlua_tointeger(L, 3); + System.Collections.Generic.IComparer _comparer = (System.Collections.Generic.IComparer)translator.GetObject(L, 4, typeof(System.Collections.Generic.IComparer)); + + gen_to_be_invoked.Sort( _index, _count, _comparer ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.Collections.Generic.List.Sort!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToArray(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.ToArray( ); + 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_TrimExcess(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.TrimExcess( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TrueForAll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + + + + { + System.Predicate _match = translator.GetDelegate>(L, 2); + + var gen_ret = gen_to_be_invoked.TrueForAll( _match ); + 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 _g_get_Capacity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Capacity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Count(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Count); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Capacity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Collections.Generic.List gen_to_be_invoked = (System.Collections.Generic.List)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Capacity = 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/System_ComponentModel_AsyncCompletedEventArgsWrap.cs b/Assets/XLua/Gen/System_ComponentModel_AsyncCompletedEventArgsWrap.cs new file mode 100644 index 000000000..ab2401622 --- /dev/null +++ b/Assets/XLua/Gen/System_ComponentModel_AsyncCompletedEventArgsWrap.cs @@ -0,0 +1,132 @@ +#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 SystemComponentModelAsyncCompletedEventArgsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(System.ComponentModel.AsyncCompletedEventArgs); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 3, 0); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Cancelled", _g_get_Cancelled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Error", _g_get_Error); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "UserState", _g_get_UserState); + + + + 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) == 4 && translator.Assignable(L, 2) && LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3) && translator.Assignable(L, 4)) + { + System.Exception _error = (System.Exception)translator.GetObject(L, 2, typeof(System.Exception)); + bool _cancelled = LuaAPI.lua_toboolean(L, 3); + object _userState = translator.GetObject(L, 4, typeof(object)); + + var gen_ret = new System.ComponentModel.AsyncCompletedEventArgs(_error, _cancelled, _userState); + 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 System.ComponentModel.AsyncCompletedEventArgs constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Cancelled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.ComponentModel.AsyncCompletedEventArgs gen_to_be_invoked = (System.ComponentModel.AsyncCompletedEventArgs)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.Cancelled); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Error(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.ComponentModel.AsyncCompletedEventArgs gen_to_be_invoked = (System.ComponentModel.AsyncCompletedEventArgs)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Error); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UserState(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.ComponentModel.AsyncCompletedEventArgs gen_to_be_invoked = (System.ComponentModel.AsyncCompletedEventArgs)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.UserState); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/System_ComponentModel_ComponentWrap.cs b/Assets/XLua/Gen/System_ComponentModel_ComponentWrap.cs new file mode 100644 index 000000000..8fe9f261c --- /dev/null +++ b/Assets/XLua/Gen/System_ComponentModel_ComponentWrap.cs @@ -0,0 +1,222 @@ +#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 SystemComponentModelComponentWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(System.ComponentModel.Component); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 2, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Dispose", _m_Dispose); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Disposed", _e_Disposed); + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Site", _g_get_Site); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Container", _g_get_Container); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Site", _s_set_Site); + + + 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 System.ComponentModel.Component(); + 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 System.ComponentModel.Component constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Dispose(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.ComponentModel.Component gen_to_be_invoked = (System.ComponentModel.Component)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Dispose( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.ComponentModel.Component gen_to_be_invoked = (System.ComponentModel.Component)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_Site(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.ComponentModel.Component gen_to_be_invoked = (System.ComponentModel.Component)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.Site); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Container(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.ComponentModel.Component gen_to_be_invoked = (System.ComponentModel.Component)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.Container); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Site(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.ComponentModel.Component gen_to_be_invoked = (System.ComponentModel.Component)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Site = (System.ComponentModel.ISite)translator.GetObject(L, 2, typeof(System.ComponentModel.ISite)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_Disposed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.ComponentModel.Component gen_to_be_invoked = (System.ComponentModel.Component)translator.FastGetCSObj(L, 1); + System.EventHandler gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.EventHandler!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.Disposed += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.Disposed -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to System.ComponentModel.Component.Disposed!"); + return 0; + } + + + + } +} diff --git a/Assets/XLua/Gen/System_ConvertWrap.cs b/Assets/XLua/Gen/System_ConvertWrap.cs new file mode 100644 index 000000000..5849e9df2 --- /dev/null +++ b/Assets/XLua/Gen/System_ConvertWrap.cs @@ -0,0 +1,4001 @@ +#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 SystemConvertWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(System.Convert); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 24, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetTypeCode", _m_GetTypeCode_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IsDBNull", _m_IsDBNull_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ChangeType", _m_ChangeType_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ToBoolean", _m_ToBoolean_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ToChar", _m_ToChar_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ToSByte", _m_ToSByte_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ToByte", _m_ToByte_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ToInt16", _m_ToInt16_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ToUInt16", _m_ToUInt16_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ToInt32", _m_ToInt32_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ToUInt32", _m_ToUInt32_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ToInt64", _m_ToInt64_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ToUInt64", _m_ToUInt64_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ToSingle", _m_ToSingle_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ToDouble", _m_ToDouble_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ToDecimal", _m_ToDecimal_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ToDateTime", _m_ToDateTime_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ToString", _m_ToString_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ToBase64String", _m_ToBase64String_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ToBase64CharArray", _m_ToBase64CharArray_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FromBase64String", _m_FromBase64String_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FromBase64CharArray", _m_FromBase64CharArray_xlua_st_); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DBNull", System.Convert.DBNull); + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "System.Convert does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetTypeCode_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + object _value = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = System.Convert.GetTypeCode( _value ); + 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_IsDBNull_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + object _value = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = System.Convert.IsDBNull( _value ); + 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_ChangeType_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + System.TypeCode _typeCode;translator.Get(L, 2, out _typeCode); + + var gen_ret = System.Convert.ChangeType( _value, _typeCode ); + translator.PushAny(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + System.Type _conversionType = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + + var gen_ret = System.Convert.ChangeType( _value, _conversionType ); + translator.PushAny(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + System.TypeCode _typeCode;translator.Get(L, 2, out _typeCode); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 3, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ChangeType( _value, _typeCode, _provider ); + translator.PushAny(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + System.Type _conversionType = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 3, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ChangeType( _value, _conversionType, _provider ); + translator.PushAny(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 System.Convert.ChangeType!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToBoolean_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)) + { + bool _value = LuaAPI.lua_toboolean(L, 1); + + var gen_ret = System.Convert.ToBoolean( _value ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + sbyte _value = (sbyte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToBoolean( _value ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + char _value = (char)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToBoolean( _value ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + byte _value = (byte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToBoolean( _value ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + short _value = (short)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToBoolean( _value ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + ushort _value = (ushort)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToBoolean( _value ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _value = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToBoolean( _value ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + uint _value = LuaAPI.xlua_touint(L, 1); + + var gen_ret = System.Convert.ToBoolean( _value ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isint64(L, 1))) + { + long _value = LuaAPI.lua_toint64(L, 1); + + var gen_ret = System.Convert.ToBoolean( _value ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isuint64(L, 1))) + { + ulong _value = LuaAPI.lua_touint64(L, 1); + + var gen_ret = System.Convert.ToBoolean( _value ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + float _value = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToBoolean( _value ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + double _value = LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToBoolean( _value ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = System.Convert.ToBoolean( _value ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _value = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.Convert.ToBoolean( _value ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || translator.IsDecimal(L, 1))) + { + decimal _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToBoolean( _value ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + System.DateTime _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToBoolean( _value ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToBoolean( _value, _provider ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _value = LuaAPI.lua_tostring(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToBoolean( _value, _provider ); + LuaAPI.lua_pushboolean(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 System.Convert.ToBoolean!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToChar_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)) + { + bool _value = LuaAPI.lua_toboolean(L, 1); + + var gen_ret = System.Convert.ToChar( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + char _value = (char)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToChar( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + sbyte _value = (sbyte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToChar( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + byte _value = (byte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToChar( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + short _value = (short)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToChar( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + ushort _value = (ushort)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToChar( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _value = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToChar( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + uint _value = LuaAPI.xlua_touint(L, 1); + + var gen_ret = System.Convert.ToChar( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isint64(L, 1))) + { + long _value = LuaAPI.lua_toint64(L, 1); + + var gen_ret = System.Convert.ToChar( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isuint64(L, 1))) + { + ulong _value = LuaAPI.lua_touint64(L, 1); + + var gen_ret = System.Convert.ToChar( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + float _value = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToChar( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + double _value = LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToChar( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = System.Convert.ToChar( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _value = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.Convert.ToChar( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || translator.IsDecimal(L, 1))) + { + decimal _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToChar( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + System.DateTime _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToChar( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToChar( _value, _provider ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _value = LuaAPI.lua_tostring(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToChar( _value, _provider ); + LuaAPI.xlua_pushinteger(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 System.Convert.ToChar!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToSByte_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)) + { + bool _value = LuaAPI.lua_toboolean(L, 1); + + var gen_ret = System.Convert.ToSByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + sbyte _value = (sbyte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToSByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + char _value = (char)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToSByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + byte _value = (byte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToSByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + short _value = (short)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToSByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + ushort _value = (ushort)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToSByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _value = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToSByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + uint _value = LuaAPI.xlua_touint(L, 1); + + var gen_ret = System.Convert.ToSByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isint64(L, 1))) + { + long _value = LuaAPI.lua_toint64(L, 1); + + var gen_ret = System.Convert.ToSByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isuint64(L, 1))) + { + ulong _value = LuaAPI.lua_touint64(L, 1); + + var gen_ret = System.Convert.ToSByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + float _value = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToSByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + double _value = LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToSByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = System.Convert.ToSByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || translator.IsDecimal(L, 1))) + { + decimal _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToSByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _value = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.Convert.ToSByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + System.DateTime _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToSByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + string _value = LuaAPI.lua_tostring(L, 1); + int _fromBase = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = System.Convert.ToSByte( _value, _fromBase ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToSByte( _value, _provider ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _value = LuaAPI.lua_tostring(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToSByte( _value, _provider ); + LuaAPI.xlua_pushinteger(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 System.Convert.ToSByte!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToByte_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)) + { + bool _value = LuaAPI.lua_toboolean(L, 1); + + var gen_ret = System.Convert.ToByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + byte _value = (byte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + char _value = (char)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + sbyte _value = (sbyte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + short _value = (short)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + ushort _value = (ushort)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _value = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + uint _value = LuaAPI.xlua_touint(L, 1); + + var gen_ret = System.Convert.ToByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isint64(L, 1))) + { + long _value = LuaAPI.lua_toint64(L, 1); + + var gen_ret = System.Convert.ToByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isuint64(L, 1))) + { + ulong _value = LuaAPI.lua_touint64(L, 1); + + var gen_ret = System.Convert.ToByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + float _value = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + double _value = LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = System.Convert.ToByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || translator.IsDecimal(L, 1))) + { + decimal _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _value = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.Convert.ToByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + System.DateTime _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToByte( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + string _value = LuaAPI.lua_tostring(L, 1); + int _fromBase = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = System.Convert.ToByte( _value, _fromBase ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToByte( _value, _provider ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _value = LuaAPI.lua_tostring(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToByte( _value, _provider ); + LuaAPI.xlua_pushinteger(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 System.Convert.ToByte!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToInt16_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)) + { + bool _value = LuaAPI.lua_toboolean(L, 1); + + var gen_ret = System.Convert.ToInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + char _value = (char)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + sbyte _value = (sbyte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + byte _value = (byte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + ushort _value = (ushort)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _value = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + uint _value = LuaAPI.xlua_touint(L, 1); + + var gen_ret = System.Convert.ToInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + short _value = (short)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isint64(L, 1))) + { + long _value = LuaAPI.lua_toint64(L, 1); + + var gen_ret = System.Convert.ToInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isuint64(L, 1))) + { + ulong _value = LuaAPI.lua_touint64(L, 1); + + var gen_ret = System.Convert.ToInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + float _value = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + double _value = LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = System.Convert.ToInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || translator.IsDecimal(L, 1))) + { + decimal _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _value = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.Convert.ToInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + System.DateTime _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + string _value = LuaAPI.lua_tostring(L, 1); + int _fromBase = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = System.Convert.ToInt16( _value, _fromBase ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToInt16( _value, _provider ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _value = LuaAPI.lua_tostring(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToInt16( _value, _provider ); + LuaAPI.xlua_pushinteger(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 System.Convert.ToInt16!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToUInt16_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)) + { + bool _value = LuaAPI.lua_toboolean(L, 1); + + var gen_ret = System.Convert.ToUInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + char _value = (char)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToUInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + sbyte _value = (sbyte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToUInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + byte _value = (byte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToUInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + short _value = (short)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToUInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _value = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToUInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + ushort _value = (ushort)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToUInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + uint _value = LuaAPI.xlua_touint(L, 1); + + var gen_ret = System.Convert.ToUInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isint64(L, 1))) + { + long _value = LuaAPI.lua_toint64(L, 1); + + var gen_ret = System.Convert.ToUInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isuint64(L, 1))) + { + ulong _value = LuaAPI.lua_touint64(L, 1); + + var gen_ret = System.Convert.ToUInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + float _value = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToUInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + double _value = LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToUInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = System.Convert.ToUInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || translator.IsDecimal(L, 1))) + { + decimal _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToUInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _value = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.Convert.ToUInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + System.DateTime _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToUInt16( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + string _value = LuaAPI.lua_tostring(L, 1); + int _fromBase = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = System.Convert.ToUInt16( _value, _fromBase ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToUInt16( _value, _provider ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _value = LuaAPI.lua_tostring(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToUInt16( _value, _provider ); + LuaAPI.xlua_pushinteger(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 System.Convert.ToUInt16!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToInt32_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)) + { + bool _value = LuaAPI.lua_toboolean(L, 1); + + var gen_ret = System.Convert.ToInt32( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + char _value = (char)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToInt32( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + sbyte _value = (sbyte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToInt32( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + byte _value = (byte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToInt32( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + short _value = (short)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToInt32( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + ushort _value = (ushort)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToInt32( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + uint _value = LuaAPI.xlua_touint(L, 1); + + var gen_ret = System.Convert.ToInt32( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _value = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToInt32( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isint64(L, 1))) + { + long _value = LuaAPI.lua_toint64(L, 1); + + var gen_ret = System.Convert.ToInt32( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isuint64(L, 1))) + { + ulong _value = LuaAPI.lua_touint64(L, 1); + + var gen_ret = System.Convert.ToInt32( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + float _value = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToInt32( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + double _value = LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToInt32( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = System.Convert.ToInt32( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || translator.IsDecimal(L, 1))) + { + decimal _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToInt32( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _value = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.Convert.ToInt32( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + System.DateTime _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToInt32( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + string _value = LuaAPI.lua_tostring(L, 1); + int _fromBase = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = System.Convert.ToInt32( _value, _fromBase ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToInt32( _value, _provider ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _value = LuaAPI.lua_tostring(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToInt32( _value, _provider ); + LuaAPI.xlua_pushinteger(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 System.Convert.ToInt32!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToUInt32_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)) + { + bool _value = LuaAPI.lua_toboolean(L, 1); + + var gen_ret = System.Convert.ToUInt32( _value ); + LuaAPI.xlua_pushuint(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + char _value = (char)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToUInt32( _value ); + LuaAPI.xlua_pushuint(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + sbyte _value = (sbyte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToUInt32( _value ); + LuaAPI.xlua_pushuint(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + byte _value = (byte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToUInt32( _value ); + LuaAPI.xlua_pushuint(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + short _value = (short)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToUInt32( _value ); + LuaAPI.xlua_pushuint(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + ushort _value = (ushort)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToUInt32( _value ); + LuaAPI.xlua_pushuint(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _value = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToUInt32( _value ); + LuaAPI.xlua_pushuint(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + uint _value = LuaAPI.xlua_touint(L, 1); + + var gen_ret = System.Convert.ToUInt32( _value ); + LuaAPI.xlua_pushuint(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isint64(L, 1))) + { + long _value = LuaAPI.lua_toint64(L, 1); + + var gen_ret = System.Convert.ToUInt32( _value ); + LuaAPI.xlua_pushuint(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isuint64(L, 1))) + { + ulong _value = LuaAPI.lua_touint64(L, 1); + + var gen_ret = System.Convert.ToUInt32( _value ); + LuaAPI.xlua_pushuint(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + float _value = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToUInt32( _value ); + LuaAPI.xlua_pushuint(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + double _value = LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToUInt32( _value ); + LuaAPI.xlua_pushuint(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = System.Convert.ToUInt32( _value ); + LuaAPI.xlua_pushuint(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || translator.IsDecimal(L, 1))) + { + decimal _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToUInt32( _value ); + LuaAPI.xlua_pushuint(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _value = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.Convert.ToUInt32( _value ); + LuaAPI.xlua_pushuint(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + System.DateTime _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToUInt32( _value ); + LuaAPI.xlua_pushuint(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + string _value = LuaAPI.lua_tostring(L, 1); + int _fromBase = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = System.Convert.ToUInt32( _value, _fromBase ); + LuaAPI.xlua_pushuint(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToUInt32( _value, _provider ); + LuaAPI.xlua_pushuint(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _value = LuaAPI.lua_tostring(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToUInt32( _value, _provider ); + LuaAPI.xlua_pushuint(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 System.Convert.ToUInt32!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToInt64_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)) + { + bool _value = LuaAPI.lua_toboolean(L, 1); + + var gen_ret = System.Convert.ToInt64( _value ); + LuaAPI.lua_pushint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + char _value = (char)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToInt64( _value ); + LuaAPI.lua_pushint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + sbyte _value = (sbyte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToInt64( _value ); + LuaAPI.lua_pushint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + byte _value = (byte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToInt64( _value ); + LuaAPI.lua_pushint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + short _value = (short)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToInt64( _value ); + LuaAPI.lua_pushint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + ushort _value = (ushort)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToInt64( _value ); + LuaAPI.lua_pushint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _value = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToInt64( _value ); + LuaAPI.lua_pushint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + uint _value = LuaAPI.xlua_touint(L, 1); + + var gen_ret = System.Convert.ToInt64( _value ); + LuaAPI.lua_pushint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isuint64(L, 1))) + { + ulong _value = LuaAPI.lua_touint64(L, 1); + + var gen_ret = System.Convert.ToInt64( _value ); + LuaAPI.lua_pushint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isint64(L, 1))) + { + long _value = LuaAPI.lua_toint64(L, 1); + + var gen_ret = System.Convert.ToInt64( _value ); + LuaAPI.lua_pushint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + float _value = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToInt64( _value ); + LuaAPI.lua_pushint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + double _value = LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToInt64( _value ); + LuaAPI.lua_pushint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = System.Convert.ToInt64( _value ); + LuaAPI.lua_pushint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || translator.IsDecimal(L, 1))) + { + decimal _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToInt64( _value ); + LuaAPI.lua_pushint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _value = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.Convert.ToInt64( _value ); + LuaAPI.lua_pushint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + System.DateTime _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToInt64( _value ); + LuaAPI.lua_pushint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + string _value = LuaAPI.lua_tostring(L, 1); + int _fromBase = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = System.Convert.ToInt64( _value, _fromBase ); + LuaAPI.lua_pushint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToInt64( _value, _provider ); + LuaAPI.lua_pushint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _value = LuaAPI.lua_tostring(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToInt64( _value, _provider ); + LuaAPI.lua_pushint64(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 System.Convert.ToInt64!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToUInt64_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)) + { + bool _value = LuaAPI.lua_toboolean(L, 1); + + var gen_ret = System.Convert.ToUInt64( _value ); + LuaAPI.lua_pushuint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + char _value = (char)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToUInt64( _value ); + LuaAPI.lua_pushuint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + sbyte _value = (sbyte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToUInt64( _value ); + LuaAPI.lua_pushuint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + byte _value = (byte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToUInt64( _value ); + LuaAPI.lua_pushuint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + short _value = (short)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToUInt64( _value ); + LuaAPI.lua_pushuint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + ushort _value = (ushort)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToUInt64( _value ); + LuaAPI.lua_pushuint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _value = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToUInt64( _value ); + LuaAPI.lua_pushuint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + uint _value = LuaAPI.xlua_touint(L, 1); + + var gen_ret = System.Convert.ToUInt64( _value ); + LuaAPI.lua_pushuint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isint64(L, 1))) + { + long _value = LuaAPI.lua_toint64(L, 1); + + var gen_ret = System.Convert.ToUInt64( _value ); + LuaAPI.lua_pushuint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isuint64(L, 1))) + { + ulong _value = LuaAPI.lua_touint64(L, 1); + + var gen_ret = System.Convert.ToUInt64( _value ); + LuaAPI.lua_pushuint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + float _value = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToUInt64( _value ); + LuaAPI.lua_pushuint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + double _value = LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToUInt64( _value ); + LuaAPI.lua_pushuint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = System.Convert.ToUInt64( _value ); + LuaAPI.lua_pushuint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || translator.IsDecimal(L, 1))) + { + decimal _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToUInt64( _value ); + LuaAPI.lua_pushuint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _value = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.Convert.ToUInt64( _value ); + LuaAPI.lua_pushuint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + System.DateTime _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToUInt64( _value ); + LuaAPI.lua_pushuint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + string _value = LuaAPI.lua_tostring(L, 1); + int _fromBase = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = System.Convert.ToUInt64( _value, _fromBase ); + LuaAPI.lua_pushuint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToUInt64( _value, _provider ); + LuaAPI.lua_pushuint64(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _value = LuaAPI.lua_tostring(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToUInt64( _value, _provider ); + LuaAPI.lua_pushuint64(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 System.Convert.ToUInt64!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToSingle_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + sbyte _value = (sbyte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToSingle( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + byte _value = (byte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToSingle( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + char _value = (char)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToSingle( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + short _value = (short)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToSingle( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + ushort _value = (ushort)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToSingle( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _value = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToSingle( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + uint _value = LuaAPI.xlua_touint(L, 1); + + var gen_ret = System.Convert.ToSingle( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isint64(L, 1))) + { + long _value = LuaAPI.lua_toint64(L, 1); + + var gen_ret = System.Convert.ToSingle( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isuint64(L, 1))) + { + ulong _value = LuaAPI.lua_touint64(L, 1); + + var gen_ret = System.Convert.ToSingle( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + float _value = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToSingle( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + double _value = LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToSingle( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)) + { + bool _value = LuaAPI.lua_toboolean(L, 1); + + var gen_ret = System.Convert.ToSingle( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = System.Convert.ToSingle( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || translator.IsDecimal(L, 1))) + { + decimal _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToSingle( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _value = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.Convert.ToSingle( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + System.DateTime _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToSingle( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToSingle( _value, _provider ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _value = LuaAPI.lua_tostring(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToSingle( _value, _provider ); + LuaAPI.lua_pushnumber(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 System.Convert.ToSingle!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToDouble_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + sbyte _value = (sbyte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToDouble( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + byte _value = (byte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToDouble( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + short _value = (short)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToDouble( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + char _value = (char)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToDouble( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + ushort _value = (ushort)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToDouble( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _value = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToDouble( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + uint _value = LuaAPI.xlua_touint(L, 1); + + var gen_ret = System.Convert.ToDouble( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isint64(L, 1))) + { + long _value = LuaAPI.lua_toint64(L, 1); + + var gen_ret = System.Convert.ToDouble( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isuint64(L, 1))) + { + ulong _value = LuaAPI.lua_touint64(L, 1); + + var gen_ret = System.Convert.ToDouble( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + float _value = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToDouble( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + double _value = LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToDouble( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)) + { + bool _value = LuaAPI.lua_toboolean(L, 1); + + var gen_ret = System.Convert.ToDouble( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = System.Convert.ToDouble( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || translator.IsDecimal(L, 1))) + { + decimal _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToDouble( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _value = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.Convert.ToDouble( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + System.DateTime _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToDouble( _value ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToDouble( _value, _provider ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _value = LuaAPI.lua_tostring(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToDouble( _value, _provider ); + LuaAPI.lua_pushnumber(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 System.Convert.ToDouble!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToDecimal_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + sbyte _value = (sbyte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToDecimal( _value ); + translator.PushDecimal(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + byte _value = (byte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToDecimal( _value ); + translator.PushDecimal(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + char _value = (char)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToDecimal( _value ); + translator.PushDecimal(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + short _value = (short)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToDecimal( _value ); + translator.PushDecimal(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + ushort _value = (ushort)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToDecimal( _value ); + translator.PushDecimal(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _value = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToDecimal( _value ); + translator.PushDecimal(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + uint _value = LuaAPI.xlua_touint(L, 1); + + var gen_ret = System.Convert.ToDecimal( _value ); + translator.PushDecimal(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isint64(L, 1))) + { + long _value = LuaAPI.lua_toint64(L, 1); + + var gen_ret = System.Convert.ToDecimal( _value ); + translator.PushDecimal(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isuint64(L, 1))) + { + ulong _value = LuaAPI.lua_touint64(L, 1); + + var gen_ret = System.Convert.ToDecimal( _value ); + translator.PushDecimal(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + float _value = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToDecimal( _value ); + translator.PushDecimal(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + double _value = LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToDecimal( _value ); + translator.PushDecimal(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)) + { + bool _value = LuaAPI.lua_toboolean(L, 1); + + var gen_ret = System.Convert.ToDecimal( _value ); + translator.PushDecimal(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = System.Convert.ToDecimal( _value ); + translator.PushDecimal(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _value = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.Convert.ToDecimal( _value ); + translator.PushDecimal(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || translator.IsDecimal(L, 1))) + { + decimal _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToDecimal( _value ); + translator.PushDecimal(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + System.DateTime _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToDecimal( _value ); + translator.PushDecimal(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToDecimal( _value, _provider ); + translator.PushDecimal(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _value = LuaAPI.lua_tostring(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToDecimal( _value, _provider ); + translator.PushDecimal(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 System.Convert.ToDecimal!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToDateTime_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + sbyte _value = (sbyte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToDateTime( _value ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + byte _value = (byte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToDateTime( _value ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + short _value = (short)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToDateTime( _value ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + ushort _value = (ushort)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToDateTime( _value ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _value = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToDateTime( _value ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + uint _value = LuaAPI.xlua_touint(L, 1); + + var gen_ret = System.Convert.ToDateTime( _value ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isint64(L, 1))) + { + long _value = LuaAPI.lua_toint64(L, 1); + + var gen_ret = System.Convert.ToDateTime( _value ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isuint64(L, 1))) + { + ulong _value = LuaAPI.lua_touint64(L, 1); + + var gen_ret = System.Convert.ToDateTime( _value ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)) + { + bool _value = LuaAPI.lua_toboolean(L, 1); + + var gen_ret = System.Convert.ToDateTime( _value ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + char _value = (char)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToDateTime( _value ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + float _value = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToDateTime( _value ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + double _value = LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToDateTime( _value ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + System.DateTime _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToDateTime( _value ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = System.Convert.ToDateTime( _value ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _value = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.Convert.ToDateTime( _value ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || translator.IsDecimal(L, 1))) + { + decimal _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToDateTime( _value ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToDateTime( _value, _provider ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _value = LuaAPI.lua_tostring(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToDateTime( _value, _provider ); + 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 System.Convert.ToDateTime!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToString_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)) + { + bool _value = LuaAPI.lua_toboolean(L, 1); + + var gen_ret = System.Convert.ToString( _value ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + char _value = (char)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToString( _value ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + sbyte _value = (sbyte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToString( _value ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + byte _value = (byte)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToString( _value ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + short _value = (short)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToString( _value ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + ushort _value = (ushort)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToString( _value ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _value = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Convert.ToString( _value ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + uint _value = LuaAPI.xlua_touint(L, 1); + + var gen_ret = System.Convert.ToString( _value ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isint64(L, 1))) + { + long _value = LuaAPI.lua_toint64(L, 1); + + var gen_ret = System.Convert.ToString( _value ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isuint64(L, 1))) + { + ulong _value = LuaAPI.lua_touint64(L, 1); + + var gen_ret = System.Convert.ToString( _value ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + float _value = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToString( _value ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + double _value = LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.Convert.ToString( _value ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + byte _value = (byte)LuaAPI.xlua_tointeger(L, 1); + int _toBase = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = System.Convert.ToString( _value, _toBase ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + short _value = (short)LuaAPI.xlua_tointeger(L, 1); + int _toBase = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = System.Convert.ToString( _value, _toBase ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _value = LuaAPI.xlua_tointeger(L, 1); + int _toBase = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = System.Convert.ToString( _value, _toBase ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isint64(L, 1))&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + long _value = LuaAPI.lua_toint64(L, 1); + int _toBase = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = System.Convert.ToString( _value, _toBase ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = System.Convert.ToString( _value ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || translator.IsDecimal(L, 1))) + { + decimal _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToString( _value ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + System.DateTime _value;translator.Get(L, 1, out _value); + + var gen_ret = System.Convert.ToString( _value ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _value = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.Convert.ToString( _value ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + bool _value = LuaAPI.lua_toboolean(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToString( _value, _provider ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + char _value = (char)LuaAPI.xlua_tointeger(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToString( _value, _provider ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + sbyte _value = (sbyte)LuaAPI.xlua_tointeger(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToString( _value, _provider ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + byte _value = (byte)LuaAPI.xlua_tointeger(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToString( _value, _provider ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + short _value = (short)LuaAPI.xlua_tointeger(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToString( _value, _provider ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + ushort _value = (ushort)LuaAPI.xlua_tointeger(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToString( _value, _provider ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + int _value = LuaAPI.xlua_tointeger(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToString( _value, _provider ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + uint _value = LuaAPI.xlua_touint(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToString( _value, _provider ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isint64(L, 1))&& translator.Assignable(L, 2)) + { + long _value = LuaAPI.lua_toint64(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToString( _value, _provider ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || LuaAPI.lua_isuint64(L, 1))&& translator.Assignable(L, 2)) + { + ulong _value = LuaAPI.lua_touint64(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToString( _value, _provider ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + float _value = (float)LuaAPI.lua_tonumber(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToString( _value, _provider ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + double _value = LuaAPI.lua_tonumber(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToString( _value, _provider ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + object _value = translator.GetObject(L, 1, typeof(object)); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToString( _value, _provider ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) || translator.IsDecimal(L, 1))&& translator.Assignable(L, 2)) + { + decimal _value;translator.Get(L, 1, out _value); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToString( _value, _provider ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + System.DateTime _value;translator.Get(L, 1, out _value); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToString( _value, _provider ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _value = LuaAPI.lua_tostring(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.Convert.ToString( _value, _provider ); + LuaAPI.lua_pushstring(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 System.Convert.ToString!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToBase64String_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)) + { + byte[] _inArray = LuaAPI.lua_tobytes(L, 1); + + var gen_ret = System.Convert.ToBase64String( _inArray ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + byte[] _inArray = LuaAPI.lua_tobytes(L, 1); + int _offset = LuaAPI.xlua_tointeger(L, 2); + int _length = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = System.Convert.ToBase64String( _inArray, _offset, _length ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + byte[] _inArray = LuaAPI.lua_tobytes(L, 1); + System.Base64FormattingOptions _options;translator.Get(L, 2, out _options); + + var gen_ret = System.Convert.ToBase64String( _inArray, _options ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + byte[] _inArray = LuaAPI.lua_tobytes(L, 1); + int _offset = LuaAPI.xlua_tointeger(L, 2); + int _length = LuaAPI.xlua_tointeger(L, 3); + System.Base64FormattingOptions _options;translator.Get(L, 4, out _options); + + var gen_ret = System.Convert.ToBase64String( _inArray, _offset, _length, _options ); + LuaAPI.lua_pushstring(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 System.Convert.ToBase64String!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToBase64CharArray_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 5&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + byte[] _inArray = LuaAPI.lua_tobytes(L, 1); + int _offsetIn = LuaAPI.xlua_tointeger(L, 2); + int _length = LuaAPI.xlua_tointeger(L, 3); + char[] _outArray = (char[])translator.GetObject(L, 4, typeof(char[])); + int _offsetOut = LuaAPI.xlua_tointeger(L, 5); + + var gen_ret = System.Convert.ToBase64CharArray( _inArray, _offsetIn, _length, _outArray, _offsetOut ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)) + { + byte[] _inArray = LuaAPI.lua_tobytes(L, 1); + int _offsetIn = LuaAPI.xlua_tointeger(L, 2); + int _length = LuaAPI.xlua_tointeger(L, 3); + char[] _outArray = (char[])translator.GetObject(L, 4, typeof(char[])); + int _offsetOut = LuaAPI.xlua_tointeger(L, 5); + System.Base64FormattingOptions _options;translator.Get(L, 6, out _options); + + var gen_ret = System.Convert.ToBase64CharArray( _inArray, _offsetIn, _length, _outArray, _offsetOut, _options ); + LuaAPI.xlua_pushinteger(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 System.Convert.ToBase64CharArray!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FromBase64String_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _s = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.Convert.FromBase64String( _s ); + 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 _m_FromBase64CharArray_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + char[] _inArray = (char[])translator.GetObject(L, 1, typeof(char[])); + int _offset = LuaAPI.xlua_tointeger(L, 2); + int _length = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = System.Convert.FromBase64CharArray( _inArray, _offset, _length ); + 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/System_DBNullWrap.cs b/Assets/XLua/Gen/System_DBNullWrap.cs new file mode 100644 index 000000000..7935fc61f --- /dev/null +++ b/Assets/XLua/Gen/System_DBNullWrap.cs @@ -0,0 +1,171 @@ +#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 SystemDBNullWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(System.DBNull); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetObjectData", _m_GetObjectData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTypeCode", _m_GetTypeCode); + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Value", System.DBNull.Value); + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "System.DBNull does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetObjectData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DBNull gen_to_be_invoked = (System.DBNull)translator.FastGetCSObj(L, 1); + + + + { + System.Runtime.Serialization.SerializationInfo _info = (System.Runtime.Serialization.SerializationInfo)translator.GetObject(L, 2, typeof(System.Runtime.Serialization.SerializationInfo)); + System.Runtime.Serialization.StreamingContext _context;translator.Get(L, 3, out _context); + + gen_to_be_invoked.GetObjectData( _info, _context ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DBNull gen_to_be_invoked = (System.DBNull)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.ToString( ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = gen_to_be_invoked.ToString( _provider ); + LuaAPI.lua_pushstring(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 System.DBNull.ToString!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetTypeCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DBNull gen_to_be_invoked = (System.DBNull)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetTypeCode( ); + 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/System_DateTimeOffsetWrap.cs b/Assets/XLua/Gen/System_DateTimeOffsetWrap.cs new file mode 100644 index 000000000..a97cf6b36 --- /dev/null +++ b/Assets/XLua/Gen/System_DateTimeOffsetWrap.cs @@ -0,0 +1,1699 @@ +#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 SystemDateTimeOffsetWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(System.DateTimeOffset); + Utils.BeginObjectRegister(type, L, translator, 5, 21, 17, 0); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__add", __AddMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__sub", __SubMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__eq", __EqMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__lt", __LTMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__le", __LEMeta); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToOffset", _m_ToOffset); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Add", _m_Add); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddDays", _m_AddDays); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddHours", _m_AddHours); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddMilliseconds", _m_AddMilliseconds); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddMinutes", _m_AddMinutes); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddMonths", _m_AddMonths); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddSeconds", _m_AddSeconds); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddTicks", _m_AddTicks); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddYears", _m_AddYears); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CompareTo", _m_CompareTo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Equals", _m_Equals); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "EqualsExact", _m_EqualsExact); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashCode", _m_GetHashCode); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Subtract", _m_Subtract); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToFileTime", _m_ToFileTime); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToUnixTimeSeconds", _m_ToUnixTimeSeconds); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToUnixTimeMilliseconds", _m_ToUnixTimeMilliseconds); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToLocalTime", _m_ToLocalTime); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToUniversalTime", _m_ToUniversalTime); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "DateTime", _g_get_DateTime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "UtcDateTime", _g_get_UtcDateTime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "LocalDateTime", _g_get_LocalDateTime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Date", _g_get_Date); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Day", _g_get_Day); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "DayOfWeek", _g_get_DayOfWeek); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "DayOfYear", _g_get_DayOfYear); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Hour", _g_get_Hour); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Millisecond", _g_get_Millisecond); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Minute", _g_get_Minute); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Month", _g_get_Month); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Offset", _g_get_Offset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Second", _g_get_Second); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Ticks", _g_get_Ticks); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "UtcTicks", _g_get_UtcTicks); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "TimeOfDay", _g_get_TimeOfDay); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Year", _g_get_Year); + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 13, 2, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Compare", _m_Compare_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Equals", _m_Equals_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FromFileTime", _m_FromFileTime_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FromUnixTimeSeconds", _m_FromUnixTimeSeconds_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FromUnixTimeMilliseconds", _m_FromUnixTimeMilliseconds_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Parse", _m_Parse_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ParseExact", _m_ParseExact_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "TryParse", _m_TryParse_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "TryParseExact", _m_TryParseExact_xlua_st_); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MinValue", System.DateTimeOffset.MinValue); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MaxValue", System.DateTimeOffset.MaxValue); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnixEpoch", System.DateTimeOffset.UnixEpoch); + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "Now", _g_get_Now); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "UtcNow", _g_get_UtcNow); + + + + 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 && (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) || LuaAPI.lua_isint64(L, 2)) && translator.Assignable(L, 3)) + { + long _ticks = LuaAPI.lua_toint64(L, 2); + System.TimeSpan _offset;translator.Get(L, 3, out _offset); + + var gen_ret = new System.DateTimeOffset(_ticks, _offset); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && translator.Assignable(L, 2)) + { + System.DateTime _dateTime;translator.Get(L, 2, out _dateTime); + + var gen_ret = new System.DateTimeOffset(_dateTime); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 3 && translator.Assignable(L, 2) && translator.Assignable(L, 3)) + { + System.DateTime _dateTime;translator.Get(L, 2, out _dateTime); + System.TimeSpan _offset;translator.Get(L, 3, out _offset); + + var gen_ret = new System.DateTimeOffset(_dateTime, _offset); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 8 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7) && translator.Assignable(L, 8)) + { + int _year = LuaAPI.xlua_tointeger(L, 2); + int _month = LuaAPI.xlua_tointeger(L, 3); + int _day = LuaAPI.xlua_tointeger(L, 4); + int _hour = LuaAPI.xlua_tointeger(L, 5); + int _minute = LuaAPI.xlua_tointeger(L, 6); + int _second = LuaAPI.xlua_tointeger(L, 7); + System.TimeSpan _offset;translator.Get(L, 8, out _offset); + + var gen_ret = new System.DateTimeOffset(_year, _month, _day, _hour, _minute, _second, _offset); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 9 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 8) && translator.Assignable(L, 9)) + { + int _year = LuaAPI.xlua_tointeger(L, 2); + int _month = LuaAPI.xlua_tointeger(L, 3); + int _day = LuaAPI.xlua_tointeger(L, 4); + int _hour = LuaAPI.xlua_tointeger(L, 5); + int _minute = LuaAPI.xlua_tointeger(L, 6); + int _second = LuaAPI.xlua_tointeger(L, 7); + int _millisecond = LuaAPI.xlua_tointeger(L, 8); + System.TimeSpan _offset;translator.Get(L, 9, out _offset); + + var gen_ret = new System.DateTimeOffset(_year, _month, _day, _hour, _minute, _second, _millisecond, _offset); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 10 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 8) && translator.Assignable(L, 9) && translator.Assignable(L, 10)) + { + int _year = LuaAPI.xlua_tointeger(L, 2); + int _month = LuaAPI.xlua_tointeger(L, 3); + int _day = LuaAPI.xlua_tointeger(L, 4); + int _hour = LuaAPI.xlua_tointeger(L, 5); + int _minute = LuaAPI.xlua_tointeger(L, 6); + int _second = LuaAPI.xlua_tointeger(L, 7); + int _millisecond = LuaAPI.xlua_tointeger(L, 8); + System.Globalization.Calendar _calendar = (System.Globalization.Calendar)translator.GetObject(L, 9, typeof(System.Globalization.Calendar)); + System.TimeSpan _offset;translator.Get(L, 10, out _offset); + + var gen_ret = new System.DateTimeOffset(_year, _month, _day, _hour, _minute, _second, _millisecond, _calendar, _offset); + translator.Push(L, gen_ret); + + return 1; + } + + if (LuaAPI.lua_gettop(L) == 1) + { + translator.Push(L, default(System.DateTimeOffset)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to System.DateTimeOffset constructor!"); + + } + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __AddMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + System.DateTimeOffset leftside;translator.Get(L, 1, out leftside); + System.TimeSpan rightside;translator.Get(L, 2, out rightside); + + translator.Push(L, leftside + rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of + operator, need System.DateTimeOffset!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __SubMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + System.DateTimeOffset leftside;translator.Get(L, 1, out leftside); + System.TimeSpan rightside;translator.Get(L, 2, out rightside); + + translator.Push(L, leftside - rightside); + + return 1; + } + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + System.DateTimeOffset leftside;translator.Get(L, 1, out leftside); + System.DateTimeOffset rightside;translator.Get(L, 2, out rightside); + + translator.Push(L, leftside - rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of - operator, need System.DateTimeOffset!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __EqMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + System.DateTimeOffset leftside;translator.Get(L, 1, out leftside); + System.DateTimeOffset rightside;translator.Get(L, 2, out rightside); + + LuaAPI.lua_pushboolean(L, leftside == rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of == operator, need System.DateTimeOffset!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __LTMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + System.DateTimeOffset leftside;translator.Get(L, 1, out leftside); + System.DateTimeOffset rightside;translator.Get(L, 2, out rightside); + + LuaAPI.lua_pushboolean(L, leftside < rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of < operator, need System.DateTimeOffset!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __LEMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + System.DateTimeOffset leftside;translator.Get(L, 1, out leftside); + System.DateTimeOffset rightside;translator.Get(L, 2, out rightside); + + LuaAPI.lua_pushboolean(L, leftside <= rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of <= operator, need System.DateTimeOffset!"); + + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToOffset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + System.TimeSpan _offset;translator.Get(L, 2, out _offset); + + var gen_ret = gen_to_be_invoked.ToOffset( _offset ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Add(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + System.TimeSpan _timeSpan;translator.Get(L, 2, out _timeSpan); + + var gen_ret = gen_to_be_invoked.Add( _timeSpan ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddDays(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + double _days = LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.AddDays( _days ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddHours(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + double _hours = LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.AddHours( _hours ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddMilliseconds(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + double _milliseconds = LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.AddMilliseconds( _milliseconds ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddMinutes(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + double _minutes = LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.AddMinutes( _minutes ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddMonths(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + int _months = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.AddMonths( _months ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddSeconds(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + double _seconds = LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.AddSeconds( _seconds ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddTicks(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + long _ticks = LuaAPI.lua_toint64(L, 2); + + var gen_ret = gen_to_be_invoked.AddTicks( _ticks ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddYears(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + int _years = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.AddYears( _years ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Compare_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.DateTimeOffset _first;translator.Get(L, 1, out _first); + System.DateTimeOffset _second;translator.Get(L, 2, out _second); + + var gen_ret = System.DateTimeOffset.Compare( _first, _second ); + 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_CompareTo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + System.DateTimeOffset _other;translator.Get(L, 2, out _other); + + var gen_ret = gen_to_be_invoked.CompareTo( _other ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Equals(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _obj = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.Equals( _obj ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.DateTimeOffset _other;translator.Get(L, 2, out _other); + + var gen_ret = gen_to_be_invoked.Equals( _other ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.DateTimeOffset.Equals!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_EqualsExact(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + System.DateTimeOffset _other;translator.Get(L, 2, out _other); + + var gen_ret = gen_to_be_invoked.EqualsExact( _other ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Equals_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.DateTimeOffset _first;translator.Get(L, 1, out _first); + System.DateTimeOffset _second;translator.Get(L, 2, out _second); + + var gen_ret = System.DateTimeOffset.Equals( _first, _second ); + 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_FromFileTime_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + long _fileTime = LuaAPI.lua_toint64(L, 1); + + var gen_ret = System.DateTimeOffset.FromFileTime( _fileTime ); + 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_FromUnixTimeSeconds_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + long _seconds = LuaAPI.lua_toint64(L, 1); + + var gen_ret = System.DateTimeOffset.FromUnixTimeSeconds( _seconds ); + 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_FromUnixTimeMilliseconds_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + long _milliseconds = LuaAPI.lua_toint64(L, 1); + + var gen_ret = System.DateTimeOffset.FromUnixTimeMilliseconds( _milliseconds ); + 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_GetHashCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.GetHashCode( ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Parse_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 _input = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.DateTimeOffset.Parse( _input ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _input = LuaAPI.lua_tostring(L, 1); + System.IFormatProvider _formatProvider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.DateTimeOffset.Parse( _input, _formatProvider ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + string _input = LuaAPI.lua_tostring(L, 1); + System.IFormatProvider _formatProvider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + System.Globalization.DateTimeStyles _styles;translator.Get(L, 3, out _styles); + + var gen_ret = System.DateTimeOffset.Parse( _input, _formatProvider, _styles ); + 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 System.DateTimeOffset.Parse!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ParseExact_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _input = LuaAPI.lua_tostring(L, 1); + string _format = LuaAPI.lua_tostring(L, 2); + System.IFormatProvider _formatProvider = (System.IFormatProvider)translator.GetObject(L, 3, typeof(System.IFormatProvider)); + + var gen_ret = System.DateTimeOffset.ParseExact( _input, _format, _formatProvider ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + string _input = LuaAPI.lua_tostring(L, 1); + string _format = LuaAPI.lua_tostring(L, 2); + System.IFormatProvider _formatProvider = (System.IFormatProvider)translator.GetObject(L, 3, typeof(System.IFormatProvider)); + System.Globalization.DateTimeStyles _styles;translator.Get(L, 4, out _styles); + + var gen_ret = System.DateTimeOffset.ParseExact( _input, _format, _formatProvider, _styles ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + string _input = LuaAPI.lua_tostring(L, 1); + string[] _formats = (string[])translator.GetObject(L, 2, typeof(string[])); + System.IFormatProvider _formatProvider = (System.IFormatProvider)translator.GetObject(L, 3, typeof(System.IFormatProvider)); + System.Globalization.DateTimeStyles _styles;translator.Get(L, 4, out _styles); + + var gen_ret = System.DateTimeOffset.ParseExact( _input, _formats, _formatProvider, _styles ); + 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 System.DateTimeOffset.ParseExact!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Subtract(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.DateTimeOffset _value;translator.Get(L, 2, out _value); + + var gen_ret = gen_to_be_invoked.Subtract( _value ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.TimeSpan _value;translator.Get(L, 2, out _value); + + var gen_ret = gen_to_be_invoked.Subtract( _value ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.DateTimeOffset.Subtract!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToFileTime(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.ToFileTime( ); + LuaAPI.lua_pushint64(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToUnixTimeSeconds(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.ToUnixTimeSeconds( ); + LuaAPI.lua_pushint64(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToUnixTimeMilliseconds(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.ToUnixTimeMilliseconds( ); + LuaAPI.lua_pushint64(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToLocalTime(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.ToLocalTime( ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.ToString( ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _format = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.ToString( _format ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.IFormatProvider _formatProvider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = gen_to_be_invoked.ToString( _formatProvider ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _format = LuaAPI.lua_tostring(L, 2); + System.IFormatProvider _formatProvider = (System.IFormatProvider)translator.GetObject(L, 3, typeof(System.IFormatProvider)); + + var gen_ret = gen_to_be_invoked.ToString( _format, _formatProvider ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.DateTimeOffset.ToString!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToUniversalTime(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.ToUniversalTime( ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TryParse_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 _input = LuaAPI.lua_tostring(L, 1); + System.DateTimeOffset _result; + + var gen_ret = System.DateTimeOffset.TryParse( _input, out _result ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _result); + + + + + return 2; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + string _input = LuaAPI.lua_tostring(L, 1); + System.IFormatProvider _formatProvider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + System.Globalization.DateTimeStyles _styles;translator.Get(L, 3, out _styles); + System.DateTimeOffset _result; + + var gen_ret = System.DateTimeOffset.TryParse( _input, _formatProvider, _styles, out _result ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _result); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.DateTimeOffset.TryParse!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TryParseExact_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + string _input = LuaAPI.lua_tostring(L, 1); + string _format = LuaAPI.lua_tostring(L, 2); + System.IFormatProvider _formatProvider = (System.IFormatProvider)translator.GetObject(L, 3, typeof(System.IFormatProvider)); + System.Globalization.DateTimeStyles _styles;translator.Get(L, 4, out _styles); + System.DateTimeOffset _result; + + var gen_ret = System.DateTimeOffset.TryParseExact( _input, _format, _formatProvider, _styles, out _result ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _result); + + + + + return 2; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + string _input = LuaAPI.lua_tostring(L, 1); + string[] _formats = (string[])translator.GetObject(L, 2, typeof(string[])); + System.IFormatProvider _formatProvider = (System.IFormatProvider)translator.GetObject(L, 3, typeof(System.IFormatProvider)); + System.Globalization.DateTimeStyles _styles;translator.Get(L, 4, out _styles); + System.DateTimeOffset _result; + + var gen_ret = System.DateTimeOffset.TryParseExact( _input, _formats, _formatProvider, _styles, out _result ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _result); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.DateTimeOffset.TryParseExact!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Now(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, System.DateTimeOffset.Now); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UtcNow(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, System.DateTimeOffset.UtcNow); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DateTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.DateTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UtcDateTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.UtcDateTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_LocalDateTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.LocalDateTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Date(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.Date); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Day(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Day); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DayOfWeek(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushSystemDayOfWeek(L, gen_to_be_invoked.DayOfWeek); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DayOfYear(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.DayOfYear); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Hour(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Hour); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Millisecond(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Millisecond); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Minute(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Minute); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Month(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Month); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Offset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.Offset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Second(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Second); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Ticks(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushint64(L, gen_to_be_invoked.Ticks); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UtcTicks(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushint64(L, gen_to_be_invoked.UtcTicks); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_TimeOfDay(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.TimeOfDay); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Year(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTimeOffset gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Year); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/System_DateTimeWrap.cs b/Assets/XLua/Gen/System_DateTimeWrap.cs new file mode 100644 index 000000000..d68a65a27 --- /dev/null +++ b/Assets/XLua/Gen/System_DateTimeWrap.cs @@ -0,0 +1,2080 @@ +#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 SystemDateTimeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(System.DateTime); + Utils.BeginObjectRegister(type, L, translator, 5, 27, 13, 0); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__add", __AddMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__sub", __SubMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__eq", __EqMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__lt", __LTMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__le", __LEMeta); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Add", _m_Add); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddDays", _m_AddDays); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddHours", _m_AddHours); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddMilliseconds", _m_AddMilliseconds); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddMinutes", _m_AddMinutes); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddMonths", _m_AddMonths); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddSeconds", _m_AddSeconds); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddTicks", _m_AddTicks); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddYears", _m_AddYears); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CompareTo", _m_CompareTo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Equals", _m_Equals); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsDaylightSavingTime", _m_IsDaylightSavingTime); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToBinary", _m_ToBinary); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashCode", _m_GetHashCode); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Subtract", _m_Subtract); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToOADate", _m_ToOADate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToFileTime", _m_ToFileTime); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToFileTimeUtc", _m_ToFileTimeUtc); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToLocalTime", _m_ToLocalTime); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToLongDateString", _m_ToLongDateString); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToLongTimeString", _m_ToLongTimeString); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToShortDateString", _m_ToShortDateString); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToShortTimeString", _m_ToShortTimeString); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToUniversalTime", _m_ToUniversalTime); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetDateTimeFormats", _m_GetDateTimeFormats); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTypeCode", _m_GetTypeCode); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Date", _g_get_Date); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Day", _g_get_Day); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "DayOfWeek", _g_get_DayOfWeek); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "DayOfYear", _g_get_DayOfYear); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Hour", _g_get_Hour); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Kind", _g_get_Kind); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Millisecond", _g_get_Millisecond); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Minute", _g_get_Minute); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Month", _g_get_Month); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Second", _g_get_Second); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Ticks", _g_get_Ticks); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "TimeOfDay", _g_get_TimeOfDay); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Year", _g_get_Year); + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 17, 3, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Compare", _m_Compare_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "DaysInMonth", _m_DaysInMonth_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Equals", _m_Equals_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FromBinary", _m_FromBinary_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FromFileTime", _m_FromFileTime_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FromFileTimeUtc", _m_FromFileTimeUtc_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FromOADate", _m_FromOADate_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SpecifyKind", _m_SpecifyKind_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IsLeapYear", _m_IsLeapYear_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Parse", _m_Parse_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ParseExact", _m_ParseExact_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "TryParse", _m_TryParse_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "TryParseExact", _m_TryParseExact_xlua_st_); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MinValue", System.DateTime.MinValue); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MaxValue", System.DateTime.MaxValue); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnixEpoch", System.DateTime.UnixEpoch); + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "Now", _g_get_Now); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "Today", _g_get_Today); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "UtcNow", _g_get_UtcNow); + + + + 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) == 2 && (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) || LuaAPI.lua_isint64(L, 2))) + { + long _ticks = LuaAPI.lua_toint64(L, 2); + + var gen_ret = new System.DateTime(_ticks); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 3 && (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) || LuaAPI.lua_isint64(L, 2)) && translator.Assignable(L, 3)) + { + long _ticks = LuaAPI.lua_toint64(L, 2); + System.DateTimeKind _kind;translator.Get(L, 3, out _kind); + + var gen_ret = new System.DateTime(_ticks, _kind); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 4 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + int _year = LuaAPI.xlua_tointeger(L, 2); + int _month = LuaAPI.xlua_tointeger(L, 3); + int _day = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = new System.DateTime(_year, _month, _day); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 5 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4) && translator.Assignable(L, 5)) + { + int _year = LuaAPI.xlua_tointeger(L, 2); + int _month = LuaAPI.xlua_tointeger(L, 3); + int _day = LuaAPI.xlua_tointeger(L, 4); + System.Globalization.Calendar _calendar = (System.Globalization.Calendar)translator.GetObject(L, 5, typeof(System.Globalization.Calendar)); + + var gen_ret = new System.DateTime(_year, _month, _day, _calendar); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 7 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)) + { + int _year = LuaAPI.xlua_tointeger(L, 2); + int _month = LuaAPI.xlua_tointeger(L, 3); + int _day = LuaAPI.xlua_tointeger(L, 4); + int _hour = LuaAPI.xlua_tointeger(L, 5); + int _minute = LuaAPI.xlua_tointeger(L, 6); + int _second = LuaAPI.xlua_tointeger(L, 7); + + var gen_ret = new System.DateTime(_year, _month, _day, _hour, _minute, _second); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 8 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7) && translator.Assignable(L, 8)) + { + int _year = LuaAPI.xlua_tointeger(L, 2); + int _month = LuaAPI.xlua_tointeger(L, 3); + int _day = LuaAPI.xlua_tointeger(L, 4); + int _hour = LuaAPI.xlua_tointeger(L, 5); + int _minute = LuaAPI.xlua_tointeger(L, 6); + int _second = LuaAPI.xlua_tointeger(L, 7); + System.DateTimeKind _kind;translator.Get(L, 8, out _kind); + + var gen_ret = new System.DateTime(_year, _month, _day, _hour, _minute, _second, _kind); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 8 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7) && translator.Assignable(L, 8)) + { + int _year = LuaAPI.xlua_tointeger(L, 2); + int _month = LuaAPI.xlua_tointeger(L, 3); + int _day = LuaAPI.xlua_tointeger(L, 4); + int _hour = LuaAPI.xlua_tointeger(L, 5); + int _minute = LuaAPI.xlua_tointeger(L, 6); + int _second = LuaAPI.xlua_tointeger(L, 7); + System.Globalization.Calendar _calendar = (System.Globalization.Calendar)translator.GetObject(L, 8, typeof(System.Globalization.Calendar)); + + var gen_ret = new System.DateTime(_year, _month, _day, _hour, _minute, _second, _calendar); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 8 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 8)) + { + int _year = LuaAPI.xlua_tointeger(L, 2); + int _month = LuaAPI.xlua_tointeger(L, 3); + int _day = LuaAPI.xlua_tointeger(L, 4); + int _hour = LuaAPI.xlua_tointeger(L, 5); + int _minute = LuaAPI.xlua_tointeger(L, 6); + int _second = LuaAPI.xlua_tointeger(L, 7); + int _millisecond = LuaAPI.xlua_tointeger(L, 8); + + var gen_ret = new System.DateTime(_year, _month, _day, _hour, _minute, _second, _millisecond); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 9 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 8) && translator.Assignable(L, 9)) + { + int _year = LuaAPI.xlua_tointeger(L, 2); + int _month = LuaAPI.xlua_tointeger(L, 3); + int _day = LuaAPI.xlua_tointeger(L, 4); + int _hour = LuaAPI.xlua_tointeger(L, 5); + int _minute = LuaAPI.xlua_tointeger(L, 6); + int _second = LuaAPI.xlua_tointeger(L, 7); + int _millisecond = LuaAPI.xlua_tointeger(L, 8); + System.DateTimeKind _kind;translator.Get(L, 9, out _kind); + + var gen_ret = new System.DateTime(_year, _month, _day, _hour, _minute, _second, _millisecond, _kind); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 9 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 8) && translator.Assignable(L, 9)) + { + int _year = LuaAPI.xlua_tointeger(L, 2); + int _month = LuaAPI.xlua_tointeger(L, 3); + int _day = LuaAPI.xlua_tointeger(L, 4); + int _hour = LuaAPI.xlua_tointeger(L, 5); + int _minute = LuaAPI.xlua_tointeger(L, 6); + int _second = LuaAPI.xlua_tointeger(L, 7); + int _millisecond = LuaAPI.xlua_tointeger(L, 8); + System.Globalization.Calendar _calendar = (System.Globalization.Calendar)translator.GetObject(L, 9, typeof(System.Globalization.Calendar)); + + var gen_ret = new System.DateTime(_year, _month, _day, _hour, _minute, _second, _millisecond, _calendar); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 10 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 8) && translator.Assignable(L, 9) && translator.Assignable(L, 10)) + { + int _year = LuaAPI.xlua_tointeger(L, 2); + int _month = LuaAPI.xlua_tointeger(L, 3); + int _day = LuaAPI.xlua_tointeger(L, 4); + int _hour = LuaAPI.xlua_tointeger(L, 5); + int _minute = LuaAPI.xlua_tointeger(L, 6); + int _second = LuaAPI.xlua_tointeger(L, 7); + int _millisecond = LuaAPI.xlua_tointeger(L, 8); + System.Globalization.Calendar _calendar = (System.Globalization.Calendar)translator.GetObject(L, 9, typeof(System.Globalization.Calendar)); + System.DateTimeKind _kind;translator.Get(L, 10, out _kind); + + var gen_ret = new System.DateTime(_year, _month, _day, _hour, _minute, _second, _millisecond, _calendar, _kind); + translator.Push(L, gen_ret); + + return 1; + } + + if (LuaAPI.lua_gettop(L) == 1) + { + translator.Push(L, default(System.DateTime)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to System.DateTime constructor!"); + + } + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __AddMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + System.DateTime leftside;translator.Get(L, 1, out leftside); + System.TimeSpan rightside;translator.Get(L, 2, out rightside); + + translator.Push(L, leftside + rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of + operator, need System.DateTime!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __SubMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + System.DateTime leftside;translator.Get(L, 1, out leftside); + System.TimeSpan rightside;translator.Get(L, 2, out rightside); + + translator.Push(L, leftside - rightside); + + return 1; + } + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + System.DateTime leftside;translator.Get(L, 1, out leftside); + System.DateTime rightside;translator.Get(L, 2, out rightside); + + translator.Push(L, leftside - rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of - operator, need System.DateTime!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __EqMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + System.DateTime leftside;translator.Get(L, 1, out leftside); + System.DateTime rightside;translator.Get(L, 2, out rightside); + + LuaAPI.lua_pushboolean(L, leftside == rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of == operator, need System.DateTime!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __LTMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + System.DateTime leftside;translator.Get(L, 1, out leftside); + System.DateTime rightside;translator.Get(L, 2, out rightside); + + LuaAPI.lua_pushboolean(L, leftside < rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of < operator, need System.DateTime!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __LEMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + System.DateTime leftside;translator.Get(L, 1, out leftside); + System.DateTime rightside;translator.Get(L, 2, out rightside); + + LuaAPI.lua_pushboolean(L, leftside <= rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of <= operator, need System.DateTime!"); + + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Add(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + System.TimeSpan _value;translator.Get(L, 2, out _value); + + var gen_ret = gen_to_be_invoked.Add( _value ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddDays(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + double _value = LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.AddDays( _value ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddHours(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + double _value = LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.AddHours( _value ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddMilliseconds(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + double _value = LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.AddMilliseconds( _value ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddMinutes(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + double _value = LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.AddMinutes( _value ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddMonths(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + int _months = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.AddMonths( _months ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddSeconds(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + double _value = LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.AddSeconds( _value ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddTicks(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + long _value = LuaAPI.lua_toint64(L, 2); + + var gen_ret = gen_to_be_invoked.AddTicks( _value ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddYears(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + int _value = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.AddYears( _value ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Compare_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.DateTime _t1;translator.Get(L, 1, out _t1); + System.DateTime _t2;translator.Get(L, 2, out _t2); + + var gen_ret = System.DateTime.Compare( _t1, _t2 ); + 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_CompareTo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _value = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.CompareTo( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.DateTime _value;translator.Get(L, 2, out _value); + + var gen_ret = gen_to_be_invoked.CompareTo( _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.DateTime.CompareTo!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DaysInMonth_xlua_st_(RealStatePtr L) + { + try { + + + + + { + int _year = LuaAPI.xlua_tointeger(L, 1); + int _month = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = System.DateTime.DaysInMonth( _year, _month ); + 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_Equals(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _value = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.Equals( _value ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.DateTime _value;translator.Get(L, 2, out _value); + + var gen_ret = gen_to_be_invoked.Equals( _value ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.DateTime.Equals!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Equals_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.DateTime _t1;translator.Get(L, 1, out _t1); + System.DateTime _t2;translator.Get(L, 2, out _t2); + + var gen_ret = System.DateTime.Equals( _t1, _t2 ); + 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_FromBinary_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + long _dateData = LuaAPI.lua_toint64(L, 1); + + var gen_ret = System.DateTime.FromBinary( _dateData ); + 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_FromFileTime_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + long _fileTime = LuaAPI.lua_toint64(L, 1); + + var gen_ret = System.DateTime.FromFileTime( _fileTime ); + 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_FromFileTimeUtc_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + long _fileTime = LuaAPI.lua_toint64(L, 1); + + var gen_ret = System.DateTime.FromFileTimeUtc( _fileTime ); + 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_FromOADate_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + double _d = LuaAPI.lua_tonumber(L, 1); + + var gen_ret = System.DateTime.FromOADate( _d ); + 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_IsDaylightSavingTime(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.IsDaylightSavingTime( ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SpecifyKind_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.DateTime _value;translator.Get(L, 1, out _value); + System.DateTimeKind _kind;translator.Get(L, 2, out _kind); + + var gen_ret = System.DateTime.SpecifyKind( _value, _kind ); + 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_ToBinary(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.ToBinary( ); + LuaAPI.lua_pushint64(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetHashCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.GetHashCode( ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsLeapYear_xlua_st_(RealStatePtr L) + { + try { + + + + + { + int _year = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.DateTime.IsLeapYear( _year ); + 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_Parse_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 _s = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.DateTime.Parse( _s ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _s = LuaAPI.lua_tostring(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = System.DateTime.Parse( _s, _provider ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + string _s = LuaAPI.lua_tostring(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + System.Globalization.DateTimeStyles _styles;translator.Get(L, 3, out _styles); + + var gen_ret = System.DateTime.Parse( _s, _provider, _styles ); + 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 System.DateTime.Parse!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ParseExact_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _s = LuaAPI.lua_tostring(L, 1); + string _format = LuaAPI.lua_tostring(L, 2); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 3, typeof(System.IFormatProvider)); + + var gen_ret = System.DateTime.ParseExact( _s, _format, _provider ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + string _s = LuaAPI.lua_tostring(L, 1); + string _format = LuaAPI.lua_tostring(L, 2); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 3, typeof(System.IFormatProvider)); + System.Globalization.DateTimeStyles _style;translator.Get(L, 4, out _style); + + var gen_ret = System.DateTime.ParseExact( _s, _format, _provider, _style ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + string _s = LuaAPI.lua_tostring(L, 1); + string[] _formats = (string[])translator.GetObject(L, 2, typeof(string[])); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 3, typeof(System.IFormatProvider)); + System.Globalization.DateTimeStyles _style;translator.Get(L, 4, out _style); + + var gen_ret = System.DateTime.ParseExact( _s, _formats, _provider, _style ); + 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 System.DateTime.ParseExact!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Subtract(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.DateTime _value;translator.Get(L, 2, out _value); + + var gen_ret = gen_to_be_invoked.Subtract( _value ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.TimeSpan _value;translator.Get(L, 2, out _value); + + var gen_ret = gen_to_be_invoked.Subtract( _value ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.DateTime.Subtract!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToOADate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.ToOADate( ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToFileTime(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.ToFileTime( ); + LuaAPI.lua_pushint64(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToFileTimeUtc(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.ToFileTimeUtc( ); + LuaAPI.lua_pushint64(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToLocalTime(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.ToLocalTime( ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToLongDateString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.ToLongDateString( ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToLongTimeString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.ToLongTimeString( ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToShortDateString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.ToShortDateString( ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToShortTimeString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.ToShortTimeString( ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.ToString( ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _format = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.ToString( _format ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = gen_to_be_invoked.ToString( _provider ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _format = LuaAPI.lua_tostring(L, 2); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 3, typeof(System.IFormatProvider)); + + var gen_ret = gen_to_be_invoked.ToString( _format, _provider ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.DateTime.ToString!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToUniversalTime(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.ToUniversalTime( ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TryParse_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 _s = LuaAPI.lua_tostring(L, 1); + System.DateTime _result; + + var gen_ret = System.DateTime.TryParse( _s, out _result ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _result); + + + + + return 2; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + string _s = LuaAPI.lua_tostring(L, 1); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + System.Globalization.DateTimeStyles _styles;translator.Get(L, 3, out _styles); + System.DateTime _result; + + var gen_ret = System.DateTime.TryParse( _s, _provider, _styles, out _result ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _result); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.DateTime.TryParse!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TryParseExact_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + string _s = LuaAPI.lua_tostring(L, 1); + string _format = LuaAPI.lua_tostring(L, 2); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 3, typeof(System.IFormatProvider)); + System.Globalization.DateTimeStyles _style;translator.Get(L, 4, out _style); + System.DateTime _result; + + var gen_ret = System.DateTime.TryParseExact( _s, _format, _provider, _style, out _result ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _result); + + + + + return 2; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + string _s = LuaAPI.lua_tostring(L, 1); + string[] _formats = (string[])translator.GetObject(L, 2, typeof(string[])); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 3, typeof(System.IFormatProvider)); + System.Globalization.DateTimeStyles _style;translator.Get(L, 4, out _style); + System.DateTime _result; + + var gen_ret = System.DateTime.TryParseExact( _s, _formats, _provider, _style, out _result ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _result); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.DateTime.TryParseExact!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetDateTimeFormats(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.GetDateTimeFormats( ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + char _format = (char)LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetDateTimeFormats( _format ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 2, typeof(System.IFormatProvider)); + + var gen_ret = gen_to_be_invoked.GetDateTimeFormats( _provider ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + char _format = (char)LuaAPI.xlua_tointeger(L, 2); + System.IFormatProvider _provider = (System.IFormatProvider)translator.GetObject(L, 3, typeof(System.IFormatProvider)); + + var gen_ret = gen_to_be_invoked.GetDateTimeFormats( _format, _provider ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.DateTime.GetDateTimeFormats!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetTypeCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.GetTypeCode( ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Date(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.Date); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Day(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Day); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DayOfWeek(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushSystemDayOfWeek(L, gen_to_be_invoked.DayOfWeek); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DayOfYear(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.DayOfYear); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Hour(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Hour); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Kind(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.Kind); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Millisecond(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Millisecond); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Minute(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Minute); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Month(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Month); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Now(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, System.DateTime.Now); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Second(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Second); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Ticks(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushint64(L, gen_to_be_invoked.Ticks); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_TimeOfDay(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.TimeOfDay); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Today(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, System.DateTime.Today); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Year(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.DateTime gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Year); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UtcNow(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, System.DateTime.UtcNow); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/System_EnumWrap.cs b/Assets/XLua/Gen/System_EnumWrap.cs new file mode 100644 index 000000000..91b406c4e --- /dev/null +++ b/Assets/XLua/Gen/System_EnumWrap.cs @@ -0,0 +1,658 @@ +#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 SystemEnumWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(System.Enum); + Utils.BeginObjectRegister(type, L, translator, 0, 6, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Equals", _m_Equals); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashCode", _m_GetHashCode); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CompareTo", _m_CompareTo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasFlag", _m_HasFlag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTypeCode", _m_GetTypeCode); + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 10, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Parse", _m_Parse_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetUnderlyingType", _m_GetUnderlyingType_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetValues", _m_GetValues_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetName", _m_GetName_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetNames", _m_GetNames_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ToObject", _m_ToObject_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IsDefined", _m_IsDefined_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Format", _m_Format_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "TryParse", _m_TryParse_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "System.Enum does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Parse_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + System.Type _enumType = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + string _value = LuaAPI.lua_tostring(L, 2); + + var gen_ret = System.Enum.Parse( _enumType, _value ); + translator.PushAny(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + System.Type _enumType = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + string _value = LuaAPI.lua_tostring(L, 2); + bool _ignoreCase = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = System.Enum.Parse( _enumType, _value, _ignoreCase ); + translator.PushAny(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 System.Enum.Parse!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetUnderlyingType_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.Type _enumType = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + + var gen_ret = System.Enum.GetUnderlyingType( _enumType ); + 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_GetValues_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.Type _enumType = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + + var gen_ret = System.Enum.GetValues( _enumType ); + 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_GetName_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.Type _enumType = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + object _value = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = System.Enum.GetName( _enumType, _value ); + 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 _m_GetNames_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.Type _enumType = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + + var gen_ret = System.Enum.GetNames( _enumType ); + 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_ToObject_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + System.Type _enumType = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + sbyte _value = (sbyte)LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = System.Enum.ToObject( _enumType, _value ); + translator.PushAny(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + System.Type _enumType = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + short _value = (short)LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = System.Enum.ToObject( _enumType, _value ); + translator.PushAny(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + System.Type _enumType = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + int _value = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = System.Enum.ToObject( _enumType, _value ); + translator.PushAny(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + System.Type _enumType = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + byte _value = (byte)LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = System.Enum.ToObject( _enumType, _value ); + translator.PushAny(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + System.Type _enumType = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + ushort _value = (ushort)LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = System.Enum.ToObject( _enumType, _value ); + translator.PushAny(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + System.Type _enumType = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + uint _value = LuaAPI.xlua_touint(L, 2); + + var gen_ret = System.Enum.ToObject( _enumType, _value ); + translator.PushAny(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) || LuaAPI.lua_isint64(L, 2))) + { + System.Type _enumType = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + long _value = LuaAPI.lua_toint64(L, 2); + + var gen_ret = System.Enum.ToObject( _enumType, _value ); + translator.PushAny(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) || LuaAPI.lua_isuint64(L, 2))) + { + System.Type _enumType = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + ulong _value = LuaAPI.lua_touint64(L, 2); + + var gen_ret = System.Enum.ToObject( _enumType, _value ); + translator.PushAny(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + System.Type _enumType = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + object _value = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = System.Enum.ToObject( _enumType, _value ); + translator.PushAny(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 System.Enum.ToObject!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsDefined_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.Type _enumType = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + object _value = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = System.Enum.IsDefined( _enumType, _value ); + 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_Format_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.Type _enumType = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + object _value = translator.GetObject(L, 2, typeof(object)); + string _format = LuaAPI.lua_tostring(L, 3); + + var gen_ret = System.Enum.Format( _enumType, _value, _format ); + 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 _m_Equals(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Enum gen_to_be_invoked = (System.Enum)translator.FastGetCSObj(L, 1); + + + + { + object _obj = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.Equals( _obj ); + 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_GetHashCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Enum gen_to_be_invoked = (System.Enum)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetHashCode( ); + 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_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Enum gen_to_be_invoked = (System.Enum)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.ToString( ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _format = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.ToString( _format ); + LuaAPI.lua_pushstring(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 System.Enum.ToString!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CompareTo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Enum gen_to_be_invoked = (System.Enum)translator.FastGetCSObj(L, 1); + + + + { + object _target = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.CompareTo( _target ); + 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_HasFlag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Enum gen_to_be_invoked = (System.Enum)translator.FastGetCSObj(L, 1); + + + + { + System.Enum _flag = (System.Enum)translator.GetObject(L, 2, typeof(System.Enum)); + + var gen_ret = gen_to_be_invoked.HasFlag( _flag ); + 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_GetTypeCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Enum gen_to_be_invoked = (System.Enum)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetTypeCode( ); + 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_TryParse_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + System.Type _enumType = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + string _value = LuaAPI.lua_tostring(L, 2); + object _result; + + var gen_ret = System.Enum.TryParse( _enumType, _value, out _result ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.PushAny(L, _result); + + + + + return 2; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + System.Type _enumType = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + string _value = LuaAPI.lua_tostring(L, 2); + bool _ignoreCase = LuaAPI.lua_toboolean(L, 3); + object _result; + + var gen_ret = System.Enum.TryParse( _enumType, _value, _ignoreCase, out _result ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.PushAny(L, _result); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.Enum.TryParse!"); + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/System_IO_FileWrap.cs b/Assets/XLua/Gen/System_IO_FileWrap.cs new file mode 100644 index 000000000..dda7edc5d --- /dev/null +++ b/Assets/XLua/Gen/System_IO_FileWrap.cs @@ -0,0 +1,1832 @@ +#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 SystemIOFileWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(System.IO.File); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 46, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "OpenText", _m_OpenText_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CreateText", _m_CreateText_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "AppendText", _m_AppendText_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Copy", _m_Copy_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Create", _m_Create_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Delete", _m_Delete_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Exists", _m_Exists_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Open", _m_Open_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetCreationTime", _m_SetCreationTime_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetCreationTimeUtc", _m_SetCreationTimeUtc_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetCreationTime", _m_GetCreationTime_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetCreationTimeUtc", _m_GetCreationTimeUtc_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetLastAccessTime", _m_SetLastAccessTime_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetLastAccessTimeUtc", _m_SetLastAccessTimeUtc_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetLastAccessTime", _m_GetLastAccessTime_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetLastAccessTimeUtc", _m_GetLastAccessTimeUtc_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetLastWriteTime", _m_SetLastWriteTime_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetLastWriteTimeUtc", _m_SetLastWriteTimeUtc_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetLastWriteTime", _m_GetLastWriteTime_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetLastWriteTimeUtc", _m_GetLastWriteTimeUtc_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetAttributes", _m_GetAttributes_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetAttributes", _m_SetAttributes_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "OpenRead", _m_OpenRead_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "OpenWrite", _m_OpenWrite_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ReadAllText", _m_ReadAllText_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "WriteAllText", _m_WriteAllText_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ReadAllBytes", _m_ReadAllBytes_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "WriteAllBytes", _m_WriteAllBytes_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ReadAllLines", _m_ReadAllLines_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ReadLines", _m_ReadLines_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "WriteAllLines", _m_WriteAllLines_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "AppendAllText", _m_AppendAllText_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "AppendAllLines", _m_AppendAllLines_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Replace", _m_Replace_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Move", _m_Move_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Encrypt", _m_Encrypt_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Decrypt", _m_Decrypt_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ReadAllTextAsync", _m_ReadAllTextAsync_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "WriteAllTextAsync", _m_WriteAllTextAsync_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ReadAllBytesAsync", _m_ReadAllBytesAsync_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "WriteAllBytesAsync", _m_WriteAllBytesAsync_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ReadAllLinesAsync", _m_ReadAllLinesAsync_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "WriteAllLinesAsync", _m_WriteAllLinesAsync_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "AppendAllTextAsync", _m_AppendAllTextAsync_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "AppendAllLinesAsync", _m_AppendAllLinesAsync_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "System.IO.File does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OpenText_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _path = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.IO.File.OpenText( _path ); + 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_CreateText_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _path = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.IO.File.CreateText( _path ); + 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_AppendText_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _path = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.IO.File.AppendText( _path ); + 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_Copy_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _sourceFileName = LuaAPI.lua_tostring(L, 1); + string _destFileName = LuaAPI.lua_tostring(L, 2); + + System.IO.File.Copy( _sourceFileName, _destFileName ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + string _sourceFileName = LuaAPI.lua_tostring(L, 1); + string _destFileName = LuaAPI.lua_tostring(L, 2); + bool _overwrite = LuaAPI.lua_toboolean(L, 3); + + System.IO.File.Copy( _sourceFileName, _destFileName, _overwrite ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.IO.File.Copy!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Create_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 _path = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.IO.File.Create( _path ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + string _path = LuaAPI.lua_tostring(L, 1); + int _bufferSize = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = System.IO.File.Create( _path, _bufferSize ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + string _path = LuaAPI.lua_tostring(L, 1); + int _bufferSize = LuaAPI.xlua_tointeger(L, 2); + System.IO.FileOptions _options;translator.Get(L, 3, out _options); + + var gen_ret = System.IO.File.Create( _path, _bufferSize, _options ); + 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 System.IO.File.Create!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Delete_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _path = LuaAPI.lua_tostring(L, 1); + + System.IO.File.Delete( _path ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Exists_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _path = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.IO.File.Exists( _path ); + 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_Open_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _path = LuaAPI.lua_tostring(L, 1); + System.IO.FileMode _mode;translator.Get(L, 2, out _mode); + + var gen_ret = System.IO.File.Open( _path, _mode ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + string _path = LuaAPI.lua_tostring(L, 1); + System.IO.FileMode _mode;translator.Get(L, 2, out _mode); + System.IO.FileAccess _access;translator.Get(L, 3, out _access); + + var gen_ret = System.IO.File.Open( _path, _mode, _access ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + string _path = LuaAPI.lua_tostring(L, 1); + System.IO.FileMode _mode;translator.Get(L, 2, out _mode); + System.IO.FileAccess _access;translator.Get(L, 3, out _access); + System.IO.FileShare _share;translator.Get(L, 4, out _share); + + var gen_ret = System.IO.File.Open( _path, _mode, _access, _share ); + 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 System.IO.File.Open!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetCreationTime_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _path = LuaAPI.lua_tostring(L, 1); + System.DateTime _creationTime;translator.Get(L, 2, out _creationTime); + + System.IO.File.SetCreationTime( _path, _creationTime ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetCreationTimeUtc_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _path = LuaAPI.lua_tostring(L, 1); + System.DateTime _creationTimeUtc;translator.Get(L, 2, out _creationTimeUtc); + + System.IO.File.SetCreationTimeUtc( _path, _creationTimeUtc ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetCreationTime_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _path = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.IO.File.GetCreationTime( _path ); + 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_GetCreationTimeUtc_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _path = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.IO.File.GetCreationTimeUtc( _path ); + 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_SetLastAccessTime_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _path = LuaAPI.lua_tostring(L, 1); + System.DateTime _lastAccessTime;translator.Get(L, 2, out _lastAccessTime); + + System.IO.File.SetLastAccessTime( _path, _lastAccessTime ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLastAccessTimeUtc_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _path = LuaAPI.lua_tostring(L, 1); + System.DateTime _lastAccessTimeUtc;translator.Get(L, 2, out _lastAccessTimeUtc); + + System.IO.File.SetLastAccessTimeUtc( _path, _lastAccessTimeUtc ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetLastAccessTime_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _path = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.IO.File.GetLastAccessTime( _path ); + 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_GetLastAccessTimeUtc_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _path = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.IO.File.GetLastAccessTimeUtc( _path ); + 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_SetLastWriteTime_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _path = LuaAPI.lua_tostring(L, 1); + System.DateTime _lastWriteTime;translator.Get(L, 2, out _lastWriteTime); + + System.IO.File.SetLastWriteTime( _path, _lastWriteTime ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLastWriteTimeUtc_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _path = LuaAPI.lua_tostring(L, 1); + System.DateTime _lastWriteTimeUtc;translator.Get(L, 2, out _lastWriteTimeUtc); + + System.IO.File.SetLastWriteTimeUtc( _path, _lastWriteTimeUtc ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetLastWriteTime_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _path = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.IO.File.GetLastWriteTime( _path ); + 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_GetLastWriteTimeUtc_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _path = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.IO.File.GetLastWriteTimeUtc( _path ); + 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_GetAttributes_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _path = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.IO.File.GetAttributes( _path ); + 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_SetAttributes_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _path = LuaAPI.lua_tostring(L, 1); + System.IO.FileAttributes _fileAttributes;translator.Get(L, 2, out _fileAttributes); + + System.IO.File.SetAttributes( _path, _fileAttributes ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OpenRead_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _path = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.IO.File.OpenRead( _path ); + 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_OpenWrite_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _path = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.IO.File.OpenWrite( _path ); + 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_ReadAllText_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 _path = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.IO.File.ReadAllText( _path ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _path = LuaAPI.lua_tostring(L, 1); + System.Text.Encoding _encoding = (System.Text.Encoding)translator.GetObject(L, 2, typeof(System.Text.Encoding)); + + var gen_ret = System.IO.File.ReadAllText( _path, _encoding ); + LuaAPI.lua_pushstring(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 System.IO.File.ReadAllText!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_WriteAllText_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _path = LuaAPI.lua_tostring(L, 1); + string _contents = LuaAPI.lua_tostring(L, 2); + + System.IO.File.WriteAllText( _path, _contents ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _path = LuaAPI.lua_tostring(L, 1); + string _contents = LuaAPI.lua_tostring(L, 2); + System.Text.Encoding _encoding = (System.Text.Encoding)translator.GetObject(L, 3, typeof(System.Text.Encoding)); + + System.IO.File.WriteAllText( _path, _contents, _encoding ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.IO.File.WriteAllText!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ReadAllBytes_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _path = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.IO.File.ReadAllBytes( _path ); + 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 _m_WriteAllBytes_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _path = LuaAPI.lua_tostring(L, 1); + byte[] _bytes = LuaAPI.lua_tobytes(L, 2); + + System.IO.File.WriteAllBytes( _path, _bytes ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ReadAllLines_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 _path = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.IO.File.ReadAllLines( _path ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _path = LuaAPI.lua_tostring(L, 1); + System.Text.Encoding _encoding = (System.Text.Encoding)translator.GetObject(L, 2, typeof(System.Text.Encoding)); + + var gen_ret = System.IO.File.ReadAllLines( _path, _encoding ); + 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 System.IO.File.ReadAllLines!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ReadLines_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 _path = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.IO.File.ReadLines( _path ); + translator.PushAny(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _path = LuaAPI.lua_tostring(L, 1); + System.Text.Encoding _encoding = (System.Text.Encoding)translator.GetObject(L, 2, typeof(System.Text.Encoding)); + + var gen_ret = System.IO.File.ReadLines( _path, _encoding ); + translator.PushAny(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 System.IO.File.ReadLines!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_WriteAllLines_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _path = LuaAPI.lua_tostring(L, 1); + string[] _contents = (string[])translator.GetObject(L, 2, typeof(string[])); + + System.IO.File.WriteAllLines( _path, _contents ); + + + + 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 _path = LuaAPI.lua_tostring(L, 1); + System.Collections.Generic.IEnumerable _contents = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEnumerable)); + + System.IO.File.WriteAllLines( _path, _contents ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + string _path = LuaAPI.lua_tostring(L, 1); + string[] _contents = (string[])translator.GetObject(L, 2, typeof(string[])); + System.Text.Encoding _encoding = (System.Text.Encoding)translator.GetObject(L, 3, typeof(System.Text.Encoding)); + + System.IO.File.WriteAllLines( _path, _contents, _encoding ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)) + { + string _path = LuaAPI.lua_tostring(L, 1); + System.Collections.Generic.IEnumerable _contents = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEnumerable)); + System.Text.Encoding _encoding = (System.Text.Encoding)translator.GetObject(L, 3, typeof(System.Text.Encoding)); + + System.IO.File.WriteAllLines( _path, _contents, _encoding ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.IO.File.WriteAllLines!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AppendAllText_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _path = LuaAPI.lua_tostring(L, 1); + string _contents = LuaAPI.lua_tostring(L, 2); + + System.IO.File.AppendAllText( _path, _contents ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _path = LuaAPI.lua_tostring(L, 1); + string _contents = LuaAPI.lua_tostring(L, 2); + System.Text.Encoding _encoding = (System.Text.Encoding)translator.GetObject(L, 3, typeof(System.Text.Encoding)); + + System.IO.File.AppendAllText( _path, _contents, _encoding ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.IO.File.AppendAllText!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AppendAllLines_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 2)) + { + string _path = LuaAPI.lua_tostring(L, 1); + System.Collections.Generic.IEnumerable _contents = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEnumerable)); + + System.IO.File.AppendAllLines( _path, _contents ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)) + { + string _path = LuaAPI.lua_tostring(L, 1); + System.Collections.Generic.IEnumerable _contents = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEnumerable)); + System.Text.Encoding _encoding = (System.Text.Encoding)translator.GetObject(L, 3, typeof(System.Text.Encoding)); + + System.IO.File.AppendAllLines( _path, _contents, _encoding ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.IO.File.AppendAllLines!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Replace_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (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 _sourceFileName = LuaAPI.lua_tostring(L, 1); + string _destinationFileName = LuaAPI.lua_tostring(L, 2); + string _destinationBackupFileName = LuaAPI.lua_tostring(L, 3); + + System.IO.File.Replace( _sourceFileName, _destinationFileName, _destinationBackupFileName ); + + + + return 0; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (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)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + string _sourceFileName = LuaAPI.lua_tostring(L, 1); + string _destinationFileName = LuaAPI.lua_tostring(L, 2); + string _destinationBackupFileName = LuaAPI.lua_tostring(L, 3); + bool _ignoreMetadataErrors = LuaAPI.lua_toboolean(L, 4); + + System.IO.File.Replace( _sourceFileName, _destinationFileName, _destinationBackupFileName, _ignoreMetadataErrors ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.IO.File.Replace!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Move_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _sourceFileName = LuaAPI.lua_tostring(L, 1); + string _destFileName = LuaAPI.lua_tostring(L, 2); + + System.IO.File.Move( _sourceFileName, _destFileName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Encrypt_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _path = LuaAPI.lua_tostring(L, 1); + + System.IO.File.Encrypt( _path ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Decrypt_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _path = LuaAPI.lua_tostring(L, 1); + + System.IO.File.Decrypt( _path ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ReadAllTextAsync_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _path = LuaAPI.lua_tostring(L, 1); + System.Threading.CancellationToken _cancellationToken;translator.Get(L, 2, out _cancellationToken); + + var gen_ret = System.IO.File.ReadAllTextAsync( _path, _cancellationToken ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _path = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.IO.File.ReadAllTextAsync( _path ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + string _path = LuaAPI.lua_tostring(L, 1); + System.Text.Encoding _encoding = (System.Text.Encoding)translator.GetObject(L, 2, typeof(System.Text.Encoding)); + System.Threading.CancellationToken _cancellationToken;translator.Get(L, 3, out _cancellationToken); + + var gen_ret = System.IO.File.ReadAllTextAsync( _path, _encoding, _cancellationToken ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _path = LuaAPI.lua_tostring(L, 1); + System.Text.Encoding _encoding = (System.Text.Encoding)translator.GetObject(L, 2, typeof(System.Text.Encoding)); + + var gen_ret = System.IO.File.ReadAllTextAsync( _path, _encoding ); + 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 System.IO.File.ReadAllTextAsync!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_WriteAllTextAsync_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _path = LuaAPI.lua_tostring(L, 1); + string _contents = LuaAPI.lua_tostring(L, 2); + System.Threading.CancellationToken _cancellationToken;translator.Get(L, 3, out _cancellationToken); + + var gen_ret = System.IO.File.WriteAllTextAsync( _path, _contents, _cancellationToken ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _path = LuaAPI.lua_tostring(L, 1); + string _contents = LuaAPI.lua_tostring(L, 2); + + var gen_ret = System.IO.File.WriteAllTextAsync( _path, _contents ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + string _path = LuaAPI.lua_tostring(L, 1); + string _contents = LuaAPI.lua_tostring(L, 2); + System.Text.Encoding _encoding = (System.Text.Encoding)translator.GetObject(L, 3, typeof(System.Text.Encoding)); + System.Threading.CancellationToken _cancellationToken;translator.Get(L, 4, out _cancellationToken); + + var gen_ret = System.IO.File.WriteAllTextAsync( _path, _contents, _encoding, _cancellationToken ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _path = LuaAPI.lua_tostring(L, 1); + string _contents = LuaAPI.lua_tostring(L, 2); + System.Text.Encoding _encoding = (System.Text.Encoding)translator.GetObject(L, 3, typeof(System.Text.Encoding)); + + var gen_ret = System.IO.File.WriteAllTextAsync( _path, _contents, _encoding ); + 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 System.IO.File.WriteAllTextAsync!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ReadAllBytesAsync_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _path = LuaAPI.lua_tostring(L, 1); + System.Threading.CancellationToken _cancellationToken;translator.Get(L, 2, out _cancellationToken); + + var gen_ret = System.IO.File.ReadAllBytesAsync( _path, _cancellationToken ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _path = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.IO.File.ReadAllBytesAsync( _path ); + 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 System.IO.File.ReadAllBytesAsync!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_WriteAllBytesAsync_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _path = LuaAPI.lua_tostring(L, 1); + byte[] _bytes = LuaAPI.lua_tobytes(L, 2); + System.Threading.CancellationToken _cancellationToken;translator.Get(L, 3, out _cancellationToken); + + var gen_ret = System.IO.File.WriteAllBytesAsync( _path, _bytes, _cancellationToken ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _path = LuaAPI.lua_tostring(L, 1); + byte[] _bytes = LuaAPI.lua_tobytes(L, 2); + + var gen_ret = System.IO.File.WriteAllBytesAsync( _path, _bytes ); + 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 System.IO.File.WriteAllBytesAsync!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ReadAllLinesAsync_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _path = LuaAPI.lua_tostring(L, 1); + System.Threading.CancellationToken _cancellationToken;translator.Get(L, 2, out _cancellationToken); + + var gen_ret = System.IO.File.ReadAllLinesAsync( _path, _cancellationToken ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _path = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.IO.File.ReadAllLinesAsync( _path ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + string _path = LuaAPI.lua_tostring(L, 1); + System.Text.Encoding _encoding = (System.Text.Encoding)translator.GetObject(L, 2, typeof(System.Text.Encoding)); + System.Threading.CancellationToken _cancellationToken;translator.Get(L, 3, out _cancellationToken); + + var gen_ret = System.IO.File.ReadAllLinesAsync( _path, _encoding, _cancellationToken ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _path = LuaAPI.lua_tostring(L, 1); + System.Text.Encoding _encoding = (System.Text.Encoding)translator.GetObject(L, 2, typeof(System.Text.Encoding)); + + var gen_ret = System.IO.File.ReadAllLinesAsync( _path, _encoding ); + 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 System.IO.File.ReadAllLinesAsync!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_WriteAllLinesAsync_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)) + { + string _path = LuaAPI.lua_tostring(L, 1); + System.Collections.Generic.IEnumerable _contents = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEnumerable)); + System.Threading.CancellationToken _cancellationToken;translator.Get(L, 3, out _cancellationToken); + + var gen_ret = System.IO.File.WriteAllLinesAsync( _path, _contents, _cancellationToken ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 2)) + { + string _path = LuaAPI.lua_tostring(L, 1); + System.Collections.Generic.IEnumerable _contents = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEnumerable)); + + var gen_ret = System.IO.File.WriteAllLinesAsync( _path, _contents ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + string _path = LuaAPI.lua_tostring(L, 1); + System.Collections.Generic.IEnumerable _contents = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEnumerable)); + System.Text.Encoding _encoding = (System.Text.Encoding)translator.GetObject(L, 3, typeof(System.Text.Encoding)); + System.Threading.CancellationToken _cancellationToken;translator.Get(L, 4, out _cancellationToken); + + var gen_ret = System.IO.File.WriteAllLinesAsync( _path, _contents, _encoding, _cancellationToken ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)) + { + string _path = LuaAPI.lua_tostring(L, 1); + System.Collections.Generic.IEnumerable _contents = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEnumerable)); + System.Text.Encoding _encoding = (System.Text.Encoding)translator.GetObject(L, 3, typeof(System.Text.Encoding)); + + var gen_ret = System.IO.File.WriteAllLinesAsync( _path, _contents, _encoding ); + 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 System.IO.File.WriteAllLinesAsync!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AppendAllTextAsync_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _path = LuaAPI.lua_tostring(L, 1); + string _contents = LuaAPI.lua_tostring(L, 2); + System.Threading.CancellationToken _cancellationToken;translator.Get(L, 3, out _cancellationToken); + + var gen_ret = System.IO.File.AppendAllTextAsync( _path, _contents, _cancellationToken ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _path = LuaAPI.lua_tostring(L, 1); + string _contents = LuaAPI.lua_tostring(L, 2); + + var gen_ret = System.IO.File.AppendAllTextAsync( _path, _contents ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + string _path = LuaAPI.lua_tostring(L, 1); + string _contents = LuaAPI.lua_tostring(L, 2); + System.Text.Encoding _encoding = (System.Text.Encoding)translator.GetObject(L, 3, typeof(System.Text.Encoding)); + System.Threading.CancellationToken _cancellationToken;translator.Get(L, 4, out _cancellationToken); + + var gen_ret = System.IO.File.AppendAllTextAsync( _path, _contents, _encoding, _cancellationToken ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _path = LuaAPI.lua_tostring(L, 1); + string _contents = LuaAPI.lua_tostring(L, 2); + System.Text.Encoding _encoding = (System.Text.Encoding)translator.GetObject(L, 3, typeof(System.Text.Encoding)); + + var gen_ret = System.IO.File.AppendAllTextAsync( _path, _contents, _encoding ); + 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 System.IO.File.AppendAllTextAsync!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AppendAllLinesAsync_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)) + { + string _path = LuaAPI.lua_tostring(L, 1); + System.Collections.Generic.IEnumerable _contents = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEnumerable)); + System.Threading.CancellationToken _cancellationToken;translator.Get(L, 3, out _cancellationToken); + + var gen_ret = System.IO.File.AppendAllLinesAsync( _path, _contents, _cancellationToken ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 2)) + { + string _path = LuaAPI.lua_tostring(L, 1); + System.Collections.Generic.IEnumerable _contents = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEnumerable)); + + var gen_ret = System.IO.File.AppendAllLinesAsync( _path, _contents ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + string _path = LuaAPI.lua_tostring(L, 1); + System.Collections.Generic.IEnumerable _contents = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEnumerable)); + System.Text.Encoding _encoding = (System.Text.Encoding)translator.GetObject(L, 3, typeof(System.Text.Encoding)); + System.Threading.CancellationToken _cancellationToken;translator.Get(L, 4, out _cancellationToken); + + var gen_ret = System.IO.File.AppendAllLinesAsync( _path, _contents, _encoding, _cancellationToken ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)) + { + string _path = LuaAPI.lua_tostring(L, 1); + System.Collections.Generic.IEnumerable _contents = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 2, typeof(System.Collections.Generic.IEnumerable)); + System.Text.Encoding _encoding = (System.Text.Encoding)translator.GetObject(L, 3, typeof(System.Text.Encoding)); + + var gen_ret = System.IO.File.AppendAllLinesAsync( _path, _contents, _encoding ); + 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 System.IO.File.AppendAllLinesAsync!"); + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/System_Net_NetworkInformation_PingCompletedEventArgsWrap.cs b/Assets/XLua/Gen/System_Net_NetworkInformation_PingCompletedEventArgsWrap.cs new file mode 100644 index 000000000..b563a975d --- /dev/null +++ b/Assets/XLua/Gen/System_Net_NetworkInformation_PingCompletedEventArgsWrap.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 SystemNetNetworkInformationPingCompletedEventArgsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(System.Net.NetworkInformation.PingCompletedEventArgs); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 1, 0); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Reply", _g_get_Reply); + + + + 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, "System.Net.NetworkInformation.PingCompletedEventArgs does not have a constructor!"); + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Reply(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Net.NetworkInformation.PingCompletedEventArgs gen_to_be_invoked = (System.Net.NetworkInformation.PingCompletedEventArgs)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Reply); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/System_Net_NetworkInformation_PingReplyWrap.cs b/Assets/XLua/Gen/System_Net_NetworkInformation_PingReplyWrap.cs new file mode 100644 index 000000000..5f4022314 --- /dev/null +++ b/Assets/XLua/Gen/System_Net_NetworkInformation_PingReplyWrap.cs @@ -0,0 +1,142 @@ +#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 SystemNetNetworkInformationPingReplyWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(System.Net.NetworkInformation.PingReply); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 5, 0); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Status", _g_get_Status); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Address", _g_get_Address); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "RoundtripTime", _g_get_RoundtripTime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Options", _g_get_Options); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Buffer", _g_get_Buffer); + + + + 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, "System.Net.NetworkInformation.PingReply does not have a constructor!"); + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Status(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Net.NetworkInformation.PingReply gen_to_be_invoked = (System.Net.NetworkInformation.PingReply)translator.FastGetCSObj(L, 1); + translator.PushSystemNetNetworkInformationIPStatus(L, gen_to_be_invoked.Status); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Address(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Net.NetworkInformation.PingReply gen_to_be_invoked = (System.Net.NetworkInformation.PingReply)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Address); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_RoundtripTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Net.NetworkInformation.PingReply gen_to_be_invoked = (System.Net.NetworkInformation.PingReply)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushint64(L, gen_to_be_invoked.RoundtripTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Options(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Net.NetworkInformation.PingReply gen_to_be_invoked = (System.Net.NetworkInformation.PingReply)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Options); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Buffer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Net.NetworkInformation.PingReply gen_to_be_invoked = (System.Net.NetworkInformation.PingReply)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Buffer); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/System_Net_NetworkInformation_PingWrap.cs b/Assets/XLua/Gen/System_Net_NetworkInformation_PingWrap.cs new file mode 100644 index 000000000..50f423946 --- /dev/null +++ b/Assets/XLua/Gen/System_Net_NetworkInformation_PingWrap.cs @@ -0,0 +1,516 @@ +#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 SystemNetNetworkInformationPingWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(System.Net.NetworkInformation.Ping); + Utils.BeginObjectRegister(type, L, translator, 0, 5, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Send", _m_Send); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SendAsync", _m_SendAsync); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SendAsyncCancel", _m_SendAsyncCancel); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SendPingAsync", _m_SendPingAsync); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PingCompleted", _e_PingCompleted); + + + + + 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 System.Net.NetworkInformation.Ping(); + 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 System.Net.NetworkInformation.Ping constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Send(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Net.NetworkInformation.Ping gen_to_be_invoked = (System.Net.NetworkInformation.Ping)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.Net.IPAddress _address = (System.Net.IPAddress)translator.GetObject(L, 2, typeof(System.Net.IPAddress)); + + var gen_ret = gen_to_be_invoked.Send( _address ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _hostNameOrAddress = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.Send( _hostNameOrAddress ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + System.Net.IPAddress _address = (System.Net.IPAddress)translator.GetObject(L, 2, typeof(System.Net.IPAddress)); + int _timeout = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.Send( _address, _timeout ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + string _hostNameOrAddress = LuaAPI.lua_tostring(L, 2); + int _timeout = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.Send( _hostNameOrAddress, _timeout ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)) + { + System.Net.IPAddress _address = (System.Net.IPAddress)translator.GetObject(L, 2, typeof(System.Net.IPAddress)); + int _timeout = LuaAPI.xlua_tointeger(L, 3); + byte[] _buffer = LuaAPI.lua_tobytes(L, 4); + + var gen_ret = gen_to_be_invoked.Send( _address, _timeout, _buffer ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)) + { + string _hostNameOrAddress = LuaAPI.lua_tostring(L, 2); + int _timeout = LuaAPI.xlua_tointeger(L, 3); + byte[] _buffer = LuaAPI.lua_tobytes(L, 4); + + var gen_ret = gen_to_be_invoked.Send( _hostNameOrAddress, _timeout, _buffer ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 5)) + { + string _hostNameOrAddress = LuaAPI.lua_tostring(L, 2); + int _timeout = LuaAPI.xlua_tointeger(L, 3); + byte[] _buffer = LuaAPI.lua_tobytes(L, 4); + System.Net.NetworkInformation.PingOptions _options = (System.Net.NetworkInformation.PingOptions)translator.GetObject(L, 5, typeof(System.Net.NetworkInformation.PingOptions)); + + var gen_ret = gen_to_be_invoked.Send( _hostNameOrAddress, _timeout, _buffer, _options ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 5)) + { + System.Net.IPAddress _address = (System.Net.IPAddress)translator.GetObject(L, 2, typeof(System.Net.IPAddress)); + int _timeout = LuaAPI.xlua_tointeger(L, 3); + byte[] _buffer = LuaAPI.lua_tobytes(L, 4); + System.Net.NetworkInformation.PingOptions _options = (System.Net.NetworkInformation.PingOptions)translator.GetObject(L, 5, typeof(System.Net.NetworkInformation.PingOptions)); + + var gen_ret = gen_to_be_invoked.Send( _address, _timeout, _buffer, _options ); + 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 System.Net.NetworkInformation.Ping.Send!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SendAsync(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Net.NetworkInformation.Ping gen_to_be_invoked = (System.Net.NetworkInformation.Ping)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + System.Net.IPAddress _address = (System.Net.IPAddress)translator.GetObject(L, 2, typeof(System.Net.IPAddress)); + object _userToken = translator.GetObject(L, 3, typeof(object)); + + gen_to_be_invoked.SendAsync( _address, _userToken ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _hostNameOrAddress = LuaAPI.lua_tostring(L, 2); + object _userToken = translator.GetObject(L, 3, typeof(object)); + + gen_to_be_invoked.SendAsync( _hostNameOrAddress, _userToken ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + System.Net.IPAddress _address = (System.Net.IPAddress)translator.GetObject(L, 2, typeof(System.Net.IPAddress)); + int _timeout = LuaAPI.xlua_tointeger(L, 3); + object _userToken = translator.GetObject(L, 4, typeof(object)); + + gen_to_be_invoked.SendAsync( _address, _timeout, _userToken ); + + + + return 0; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + string _hostNameOrAddress = LuaAPI.lua_tostring(L, 2); + int _timeout = LuaAPI.xlua_tointeger(L, 3); + object _userToken = translator.GetObject(L, 4, typeof(object)); + + gen_to_be_invoked.SendAsync( _hostNameOrAddress, _timeout, _userToken ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 5)) + { + System.Net.IPAddress _address = (System.Net.IPAddress)translator.GetObject(L, 2, typeof(System.Net.IPAddress)); + int _timeout = LuaAPI.xlua_tointeger(L, 3); + byte[] _buffer = LuaAPI.lua_tobytes(L, 4); + object _userToken = translator.GetObject(L, 5, typeof(object)); + + gen_to_be_invoked.SendAsync( _address, _timeout, _buffer, _userToken ); + + + + return 0; + } + if(gen_param_count == 5&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 5)) + { + string _hostNameOrAddress = LuaAPI.lua_tostring(L, 2); + int _timeout = LuaAPI.xlua_tointeger(L, 3); + byte[] _buffer = LuaAPI.lua_tobytes(L, 4); + object _userToken = translator.GetObject(L, 5, typeof(object)); + + gen_to_be_invoked.SendAsync( _hostNameOrAddress, _timeout, _buffer, _userToken ); + + + + return 0; + } + if(gen_param_count == 6&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 5)&& translator.Assignable(L, 6)) + { + string _hostNameOrAddress = LuaAPI.lua_tostring(L, 2); + int _timeout = LuaAPI.xlua_tointeger(L, 3); + byte[] _buffer = LuaAPI.lua_tobytes(L, 4); + System.Net.NetworkInformation.PingOptions _options = (System.Net.NetworkInformation.PingOptions)translator.GetObject(L, 5, typeof(System.Net.NetworkInformation.PingOptions)); + object _userToken = translator.GetObject(L, 6, typeof(object)); + + gen_to_be_invoked.SendAsync( _hostNameOrAddress, _timeout, _buffer, _options, _userToken ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 5)&& translator.Assignable(L, 6)) + { + System.Net.IPAddress _address = (System.Net.IPAddress)translator.GetObject(L, 2, typeof(System.Net.IPAddress)); + int _timeout = LuaAPI.xlua_tointeger(L, 3); + byte[] _buffer = LuaAPI.lua_tobytes(L, 4); + System.Net.NetworkInformation.PingOptions _options = (System.Net.NetworkInformation.PingOptions)translator.GetObject(L, 5, typeof(System.Net.NetworkInformation.PingOptions)); + object _userToken = translator.GetObject(L, 6, typeof(object)); + + gen_to_be_invoked.SendAsync( _address, _timeout, _buffer, _options, _userToken ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.Net.NetworkInformation.Ping.SendAsync!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SendAsyncCancel(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Net.NetworkInformation.Ping gen_to_be_invoked = (System.Net.NetworkInformation.Ping)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SendAsyncCancel( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SendPingAsync(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Net.NetworkInformation.Ping gen_to_be_invoked = (System.Net.NetworkInformation.Ping)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.Net.IPAddress _address = (System.Net.IPAddress)translator.GetObject(L, 2, typeof(System.Net.IPAddress)); + + var gen_ret = gen_to_be_invoked.SendPingAsync( _address ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _hostNameOrAddress = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.SendPingAsync( _hostNameOrAddress ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + System.Net.IPAddress _address = (System.Net.IPAddress)translator.GetObject(L, 2, typeof(System.Net.IPAddress)); + int _timeout = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.SendPingAsync( _address, _timeout ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + string _hostNameOrAddress = LuaAPI.lua_tostring(L, 2); + int _timeout = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.SendPingAsync( _hostNameOrAddress, _timeout ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)) + { + System.Net.IPAddress _address = (System.Net.IPAddress)translator.GetObject(L, 2, typeof(System.Net.IPAddress)); + int _timeout = LuaAPI.xlua_tointeger(L, 3); + byte[] _buffer = LuaAPI.lua_tobytes(L, 4); + + var gen_ret = gen_to_be_invoked.SendPingAsync( _address, _timeout, _buffer ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)) + { + string _hostNameOrAddress = LuaAPI.lua_tostring(L, 2); + int _timeout = LuaAPI.xlua_tointeger(L, 3); + byte[] _buffer = LuaAPI.lua_tobytes(L, 4); + + var gen_ret = gen_to_be_invoked.SendPingAsync( _hostNameOrAddress, _timeout, _buffer ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 5)) + { + string _hostNameOrAddress = LuaAPI.lua_tostring(L, 2); + int _timeout = LuaAPI.xlua_tointeger(L, 3); + byte[] _buffer = LuaAPI.lua_tobytes(L, 4); + System.Net.NetworkInformation.PingOptions _options = (System.Net.NetworkInformation.PingOptions)translator.GetObject(L, 5, typeof(System.Net.NetworkInformation.PingOptions)); + + var gen_ret = gen_to_be_invoked.SendPingAsync( _hostNameOrAddress, _timeout, _buffer, _options ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 5)) + { + System.Net.IPAddress _address = (System.Net.IPAddress)translator.GetObject(L, 2, typeof(System.Net.IPAddress)); + int _timeout = LuaAPI.xlua_tointeger(L, 3); + byte[] _buffer = LuaAPI.lua_tobytes(L, 4); + System.Net.NetworkInformation.PingOptions _options = (System.Net.NetworkInformation.PingOptions)translator.GetObject(L, 5, typeof(System.Net.NetworkInformation.PingOptions)); + + var gen_ret = gen_to_be_invoked.SendPingAsync( _address, _timeout, _buffer, _options ); + 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 System.Net.NetworkInformation.Ping.SendPingAsync!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_PingCompleted(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Net.NetworkInformation.Ping gen_to_be_invoked = (System.Net.NetworkInformation.Ping)translator.FastGetCSObj(L, 1); + System.Net.NetworkInformation.PingCompletedEventHandler gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Net.NetworkInformation.PingCompletedEventHandler!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.PingCompleted += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.PingCompleted -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to System.Net.NetworkInformation.Ping.PingCompleted!"); + return 0; + } + + + + } +} diff --git a/Assets/XLua/Gen/System_ObjectWrap.cs b/Assets/XLua/Gen/System_ObjectWrap.cs new file mode 100644 index 000000000..d6f96cded --- /dev/null +++ b/Assets/XLua/Gen/System_ObjectWrap.cs @@ -0,0 +1,259 @@ +#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 SystemObjectWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(object); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Equals", _m_Equals); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashCode", _m_GetHashCode); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetType", _m_GetType); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 3, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Equals", _m_Equals_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ReferenceEquals", _m_ReferenceEquals_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 object(); + translator.PushAny(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 object constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Equals(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + object gen_to_be_invoked = translator.FastGetCSObj(L, 1); + + + + { + object _obj = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.Equals( _obj ); + 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_Equals_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + object _objA = translator.GetObject(L, 1, typeof(object)); + object _objB = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = object.Equals( _objA, _objB ); + 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_GetHashCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + object gen_to_be_invoked = translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetHashCode( ); + 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_GetType(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + object gen_to_be_invoked = translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetType( ); + 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_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + object gen_to_be_invoked = 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 _m_ReferenceEquals_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + object _objA = translator.GetObject(L, 1, typeof(object)); + object _objB = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = object.ReferenceEquals( _objA, _objB ); + LuaAPI.lua_pushboolean(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/System_UriWrap.cs b/Assets/XLua/Gen/System_UriWrap.cs new file mode 100644 index 000000000..00f6922cf --- /dev/null +++ b/Assets/XLua/Gen/System_UriWrap.cs @@ -0,0 +1,1114 @@ +#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 SystemUriWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(System.Uri); + Utils.BeginObjectRegister(type, L, translator, 1, 8, 22, 0); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__eq", __EqMeta); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetLeftPart", _m_GetLeftPart); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashCode", _m_GetHashCode); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Equals", _m_Equals); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "MakeRelativeUri", _m_MakeRelativeUri); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetComponents", _m_GetComponents); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsWellFormedOriginalString", _m_IsWellFormedOriginalString); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsBaseOf", _m_IsBaseOf); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AbsolutePath", _g_get_AbsolutePath); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AbsoluteUri", _g_get_AbsoluteUri); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "LocalPath", _g_get_LocalPath); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Authority", _g_get_Authority); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "HostNameType", _g_get_HostNameType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsDefaultPort", _g_get_IsDefaultPort); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsFile", _g_get_IsFile); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsLoopback", _g_get_IsLoopback); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "PathAndQuery", _g_get_PathAndQuery); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Segments", _g_get_Segments); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsUnc", _g_get_IsUnc); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Host", _g_get_Host); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Port", _g_get_Port); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Query", _g_get_Query); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Fragment", _g_get_Fragment); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Scheme", _g_get_Scheme); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "OriginalString", _g_get_OriginalString); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "DnsSafeHost", _g_get_DnsSafeHost); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IdnHost", _g_get_IdnHost); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsAbsoluteUri", _g_get_IsAbsoluteUri); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "UserEscaped", _g_get_UserEscaped); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "UserInfo", _g_get_UserInfo); + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 25, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CheckHostName", _m_CheckHostName_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "HexEscape", _m_HexEscape_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "HexUnescape", _m_HexUnescape_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IsHexEncoding", _m_IsHexEncoding_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CheckSchemeName", _m_CheckSchemeName_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IsHexDigit", _m_IsHexDigit_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FromHex", _m_FromHex_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "TryCreate", _m_TryCreate_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Compare", _m_Compare_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IsWellFormedUriString", _m_IsWellFormedUriString_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "UnescapeDataString", _m_UnescapeDataString_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "EscapeUriString", _m_EscapeUriString_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "EscapeDataString", _m_EscapeDataString_xlua_st_); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UriSchemeFile", System.Uri.UriSchemeFile); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UriSchemeFtp", System.Uri.UriSchemeFtp); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UriSchemeGopher", System.Uri.UriSchemeGopher); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UriSchemeHttp", System.Uri.UriSchemeHttp); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UriSchemeHttps", System.Uri.UriSchemeHttps); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UriSchemeMailto", System.Uri.UriSchemeMailto); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UriSchemeNews", System.Uri.UriSchemeNews); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UriSchemeNntp", System.Uri.UriSchemeNntp); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UriSchemeNetTcp", System.Uri.UriSchemeNetTcp); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UriSchemeNetPipe", System.Uri.UriSchemeNetPipe); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SchemeDelimiter", System.Uri.SchemeDelimiter); + + + + + 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) == 2 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _uriString = LuaAPI.lua_tostring(L, 2); + + var gen_ret = new System.Uri(_uriString); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 3 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING) && translator.Assignable(L, 3)) + { + string _uriString = LuaAPI.lua_tostring(L, 2); + System.UriKind _uriKind;translator.Get(L, 3, out _uriKind); + + var gen_ret = new System.Uri(_uriString, _uriKind); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 3 && translator.Assignable(L, 2) && (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + System.Uri _baseUri = (System.Uri)translator.GetObject(L, 2, typeof(System.Uri)); + string _relativeUri = LuaAPI.lua_tostring(L, 3); + + var gen_ret = new System.Uri(_baseUri, _relativeUri); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 3 && translator.Assignable(L, 2) && translator.Assignable(L, 3)) + { + System.Uri _baseUri = (System.Uri)translator.GetObject(L, 2, typeof(System.Uri)); + System.Uri _relativeUri = (System.Uri)translator.GetObject(L, 3, typeof(System.Uri)); + + var gen_ret = new System.Uri(_baseUri, _relativeUri); + 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 System.Uri constructor!"); + + } + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __EqMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + System.Uri leftside = (System.Uri)translator.GetObject(L, 1, typeof(System.Uri)); + System.Uri rightside = (System.Uri)translator.GetObject(L, 2, typeof(System.Uri)); + + LuaAPI.lua_pushboolean(L, leftside == rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of == operator, need System.Uri!"); + + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CheckHostName_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _name = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.Uri.CheckHostName( _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_GetLeftPart(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Uri gen_to_be_invoked = (System.Uri)translator.FastGetCSObj(L, 1); + + + + { + System.UriPartial _part;translator.Get(L, 2, out _part); + + var gen_ret = gen_to_be_invoked.GetLeftPart( _part ); + 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 _m_HexEscape_xlua_st_(RealStatePtr L) + { + try { + + + + + { + char _character = (char)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Uri.HexEscape( _character ); + 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 _m_HexUnescape_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _pattern = LuaAPI.lua_tostring(L, 1); + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = System.Uri.HexUnescape( _pattern, ref _index ); + LuaAPI.xlua_pushinteger(L, gen_ret); + LuaAPI.xlua_pushinteger(L, _index); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsHexEncoding_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _pattern = LuaAPI.lua_tostring(L, 1); + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = System.Uri.IsHexEncoding( _pattern, _index ); + 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_CheckSchemeName_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _schemeName = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.Uri.CheckSchemeName( _schemeName ); + 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_IsHexDigit_xlua_st_(RealStatePtr L) + { + try { + + + + + { + char _character = (char)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Uri.IsHexDigit( _character ); + 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_FromHex_xlua_st_(RealStatePtr L) + { + try { + + + + + { + char _digit = (char)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = System.Uri.FromHex( _digit ); + 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_GetHashCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Uri gen_to_be_invoked = (System.Uri)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetHashCode( ); + 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_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Uri gen_to_be_invoked = (System.Uri)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 _m_Equals(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Uri gen_to_be_invoked = (System.Uri)translator.FastGetCSObj(L, 1); + + + + { + object _comparand = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.Equals( _comparand ); + 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_MakeRelativeUri(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Uri gen_to_be_invoked = (System.Uri)translator.FastGetCSObj(L, 1); + + + + { + System.Uri _uri = (System.Uri)translator.GetObject(L, 2, typeof(System.Uri)); + + var gen_ret = gen_to_be_invoked.MakeRelativeUri( _uri ); + 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_TryCreate_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _uriString = LuaAPI.lua_tostring(L, 1); + System.UriKind _uriKind;translator.Get(L, 2, out _uriKind); + System.Uri _result; + + var gen_ret = System.Uri.TryCreate( _uriString, _uriKind, out _result ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _result); + + + + + return 2; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + System.Uri _baseUri = (System.Uri)translator.GetObject(L, 1, typeof(System.Uri)); + string _relativeUri = LuaAPI.lua_tostring(L, 2); + System.Uri _result; + + var gen_ret = System.Uri.TryCreate( _baseUri, _relativeUri, out _result ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _result); + + + + + return 2; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + System.Uri _baseUri = (System.Uri)translator.GetObject(L, 1, typeof(System.Uri)); + System.Uri _relativeUri = (System.Uri)translator.GetObject(L, 2, typeof(System.Uri)); + System.Uri _result; + + var gen_ret = System.Uri.TryCreate( _baseUri, _relativeUri, out _result ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _result); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to System.Uri.TryCreate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetComponents(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Uri gen_to_be_invoked = (System.Uri)translator.FastGetCSObj(L, 1); + + + + { + System.UriComponents _components;translator.Get(L, 2, out _components); + System.UriFormat _format;translator.Get(L, 3, out _format); + + var gen_ret = gen_to_be_invoked.GetComponents( _components, _format ); + 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 _m_Compare_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.Uri _uri1 = (System.Uri)translator.GetObject(L, 1, typeof(System.Uri)); + System.Uri _uri2 = (System.Uri)translator.GetObject(L, 2, typeof(System.Uri)); + System.UriComponents _partsToCompare;translator.Get(L, 3, out _partsToCompare); + System.UriFormat _compareFormat;translator.Get(L, 4, out _compareFormat); + System.StringComparison _comparisonType;translator.Get(L, 5, out _comparisonType); + + var gen_ret = System.Uri.Compare( _uri1, _uri2, _partsToCompare, _compareFormat, _comparisonType ); + 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_IsWellFormedOriginalString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Uri gen_to_be_invoked = (System.Uri)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsWellFormedOriginalString( ); + 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_IsWellFormedUriString_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _uriString = LuaAPI.lua_tostring(L, 1); + System.UriKind _uriKind;translator.Get(L, 2, out _uriKind); + + var gen_ret = System.Uri.IsWellFormedUriString( _uriString, _uriKind ); + 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_UnescapeDataString_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _stringToUnescape = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.Uri.UnescapeDataString( _stringToUnescape ); + 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 _m_EscapeUriString_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _stringToEscape = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.Uri.EscapeUriString( _stringToEscape ); + 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 _m_EscapeDataString_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _stringToEscape = LuaAPI.lua_tostring(L, 1); + + var gen_ret = System.Uri.EscapeDataString( _stringToEscape ); + 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 _m_IsBaseOf(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.Uri gen_to_be_invoked = (System.Uri)translator.FastGetCSObj(L, 1); + + + + { + System.Uri _uri = (System.Uri)translator.GetObject(L, 2, typeof(System.Uri)); + + var gen_ret = gen_to_be_invoked.IsBaseOf( _uri ); + 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 _g_get_AbsolutePath(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Uri gen_to_be_invoked = (System.Uri)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.AbsolutePath); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AbsoluteUri(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Uri gen_to_be_invoked = (System.Uri)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.AbsoluteUri); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_LocalPath(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Uri gen_to_be_invoked = (System.Uri)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.LocalPath); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Authority(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Uri gen_to_be_invoked = (System.Uri)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Authority); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_HostNameType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Uri gen_to_be_invoked = (System.Uri)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.HostNameType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsDefaultPort(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Uri gen_to_be_invoked = (System.Uri)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsDefaultPort); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsFile(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Uri gen_to_be_invoked = (System.Uri)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsFile); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsLoopback(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Uri gen_to_be_invoked = (System.Uri)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsLoopback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_PathAndQuery(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Uri gen_to_be_invoked = (System.Uri)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.PathAndQuery); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Segments(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Uri gen_to_be_invoked = (System.Uri)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Segments); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsUnc(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Uri gen_to_be_invoked = (System.Uri)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsUnc); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Host(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Uri gen_to_be_invoked = (System.Uri)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Host); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Port(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Uri gen_to_be_invoked = (System.Uri)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Port); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Query(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Uri gen_to_be_invoked = (System.Uri)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Query); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Fragment(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Uri gen_to_be_invoked = (System.Uri)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Fragment); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Scheme(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Uri gen_to_be_invoked = (System.Uri)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Scheme); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_OriginalString(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Uri gen_to_be_invoked = (System.Uri)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.OriginalString); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DnsSafeHost(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Uri gen_to_be_invoked = (System.Uri)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.DnsSafeHost); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IdnHost(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Uri gen_to_be_invoked = (System.Uri)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.IdnHost); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsAbsoluteUri(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Uri gen_to_be_invoked = (System.Uri)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsAbsoluteUri); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UserEscaped(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Uri gen_to_be_invoked = (System.Uri)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.UserEscaped); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_UserInfo(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + System.Uri gen_to_be_invoked = (System.Uri)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.UserInfo); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/System_ValueTypeWrap.cs b/Assets/XLua/Gen/System_ValueTypeWrap.cs new file mode 100644 index 000000000..a11cb5941 --- /dev/null +++ b/Assets/XLua/Gen/System_ValueTypeWrap.cs @@ -0,0 +1,155 @@ +#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 SystemValueTypeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(System.ValueType); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Equals", _m_Equals); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashCode", _m_GetHashCode); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + + + + + + 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, "System.ValueType does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Equals(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.ValueType gen_to_be_invoked = (System.ValueType)translator.FastGetCSObj(L, 1); + + + + { + object _obj = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.Equals( _obj ); + 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_GetHashCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.ValueType gen_to_be_invoked = (System.ValueType)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetHashCode( ); + 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_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + System.ValueType gen_to_be_invoked = (System.ValueType)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); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/TAExampleWrap.cs b/Assets/XLua/Gen/TAExampleWrap.cs new file mode 100644 index 000000000..a74968260 --- /dev/null +++ b/Assets/XLua/Gen/TAExampleWrap.cs @@ -0,0 +1,144 @@ +#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 TAExampleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(TAExample); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 1, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetDynamicSuperProperties", _m_GetDynamicSuperProperties); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "skin", _g_get_skin); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "skin", _s_set_skin); + + + 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 TAExample(); + 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 TAExample constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetDynamicSuperProperties(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TAExample gen_to_be_invoked = (TAExample)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetDynamicSuperProperties( ); + 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_skin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TAExample gen_to_be_invoked = (TAExample)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.skin); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_skin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TAExample gen_to_be_invoked = (TAExample)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.skin = (UnityEngine.GUISkin)translator.GetObject(L, 2, typeof(UnityEngine.GUISkin)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/TMP_AnimationCurveWrap.cs b/Assets/XLua/Gen/TMP_AnimationCurveWrap.cs new file mode 100644 index 000000000..942d49854 --- /dev/null +++ b/Assets/XLua/Gen/TMP_AnimationCurveWrap.cs @@ -0,0 +1,270 @@ +#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 TMP_AnimationCurveWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(TMP_AnimationCurve); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 6, 6); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "animationCurveY", _g_get_animationCurveY); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "animationCurveZ", _g_get_animationCurveZ); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "curveScaleY", _g_get_curveScaleY); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "useForWidth", _g_get_useForWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "curveScaleZ", _g_get_curveScaleZ); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enableZ", _g_get_enableZ); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "animationCurveY", _s_set_animationCurveY); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "animationCurveZ", _s_set_animationCurveZ); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "curveScaleY", _s_set_curveScaleY); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "useForWidth", _s_set_useForWidth); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "curveScaleZ", _s_set_curveScaleZ); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enableZ", _s_set_enableZ); + + + 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 TMP_AnimationCurve(); + 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 TMP_AnimationCurve constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_animationCurveY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMP_AnimationCurve gen_to_be_invoked = (TMP_AnimationCurve)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.animationCurveY); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_animationCurveZ(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMP_AnimationCurve gen_to_be_invoked = (TMP_AnimationCurve)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.animationCurveZ); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_curveScaleY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMP_AnimationCurve gen_to_be_invoked = (TMP_AnimationCurve)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.curveScaleY); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_useForWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMP_AnimationCurve gen_to_be_invoked = (TMP_AnimationCurve)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.useForWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_curveScaleZ(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMP_AnimationCurve gen_to_be_invoked = (TMP_AnimationCurve)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.curveScaleZ); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enableZ(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMP_AnimationCurve gen_to_be_invoked = (TMP_AnimationCurve)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.enableZ); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_animationCurveY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMP_AnimationCurve gen_to_be_invoked = (TMP_AnimationCurve)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.animationCurveY = (UnityEngine.AnimationCurve)translator.GetObject(L, 2, typeof(UnityEngine.AnimationCurve)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_animationCurveZ(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMP_AnimationCurve gen_to_be_invoked = (TMP_AnimationCurve)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.animationCurveZ = (UnityEngine.AnimationCurve)translator.GetObject(L, 2, typeof(UnityEngine.AnimationCurve)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_curveScaleY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMP_AnimationCurve gen_to_be_invoked = (TMP_AnimationCurve)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.curveScaleY = (float)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_useForWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMP_AnimationCurve gen_to_be_invoked = (TMP_AnimationCurve)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.useForWidth = (float)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_curveScaleZ(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMP_AnimationCurve gen_to_be_invoked = (TMP_AnimationCurve)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.curveScaleZ = (float)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_enableZ(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMP_AnimationCurve gen_to_be_invoked = (TMP_AnimationCurve)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.enableZ = LuaAPI.lua_toboolean(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/TMP_CurveWrap.cs b/Assets/XLua/Gen/TMP_CurveWrap.cs new file mode 100644 index 000000000..f92f5d7ec --- /dev/null +++ b/Assets/XLua/Gen/TMP_CurveWrap.cs @@ -0,0 +1,98 @@ +#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 TMP_CurveWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(TMP_Curve); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 1, 1); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ForceUpdate", _g_get_ForceUpdate); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ForceUpdate", _s_set_ForceUpdate); + + + 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, "TMP_Curve does not have a constructor!"); + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ForceUpdate(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMP_Curve gen_to_be_invoked = (TMP_Curve)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.ForceUpdate); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_ForceUpdate(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMP_Curve gen_to_be_invoked = (TMP_Curve)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ForceUpdate = LuaAPI.lua_toboolean(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/TMPro_TMP_CharacterWrap.cs b/Assets/XLua/Gen/TMPro_TMP_CharacterWrap.cs new file mode 100644 index 000000000..b21cd0d6b --- /dev/null +++ b/Assets/XLua/Gen/TMPro_TMP_CharacterWrap.cs @@ -0,0 +1,105 @@ +#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 TMProTMP_CharacterWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(TMPro.TMP_Character); + 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) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new TMPro.TMP_Character(); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 3 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && translator.Assignable(L, 3)) + { + uint _unicode = LuaAPI.xlua_touint(L, 2); + UnityEngine.TextCore.Glyph _glyph = (UnityEngine.TextCore.Glyph)translator.GetObject(L, 3, typeof(UnityEngine.TextCore.Glyph)); + + var gen_ret = new TMPro.TMP_Character(_unicode, _glyph); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 4 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && translator.Assignable(L, 3) && translator.Assignable(L, 4)) + { + uint _unicode = LuaAPI.xlua_touint(L, 2); + TMPro.TMP_FontAsset _fontAsset = (TMPro.TMP_FontAsset)translator.GetObject(L, 3, typeof(TMPro.TMP_FontAsset)); + UnityEngine.TextCore.Glyph _glyph = (UnityEngine.TextCore.Glyph)translator.GetObject(L, 4, typeof(UnityEngine.TextCore.Glyph)); + + var gen_ret = new TMPro.TMP_Character(_unicode, _fontAsset, _glyph); + 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 TMPro.TMP_Character constructor!"); + + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/TMPro_TMP_DropdownWrap.cs b/Assets/XLua/Gen/TMPro_TMP_DropdownWrap.cs new file mode 100644 index 000000000..15864e6d5 --- /dev/null +++ b/Assets/XLua/Gen/TMPro_TMP_DropdownWrap.cs @@ -0,0 +1,673 @@ +#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 TMProTMP_DropdownWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(TMPro.TMP_Dropdown); + Utils.BeginObjectRegister(type, L, translator, 0, 9, 11, 10); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetValueWithoutNotify", _m_SetValueWithoutNotify); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshShownValue", _m_RefreshShownValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddOptions", _m_AddOptions); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearOptions", _m_ClearOptions); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerClick", _m_OnPointerClick); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnSubmit", _m_OnSubmit); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnCancel", _m_OnCancel); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Show", _m_Show); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Hide", _m_Hide); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "template", _g_get_template); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "captionText", _g_get_captionText); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "captionImage", _g_get_captionImage); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "placeholder", _g_get_placeholder); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "itemText", _g_get_itemText); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "itemImage", _g_get_itemImage); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "options", _g_get_options); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onValueChanged", _g_get_onValueChanged); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "alphaFadeSpeed", _g_get_alphaFadeSpeed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "value", _g_get_value); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsExpanded", _g_get_IsExpanded); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "template", _s_set_template); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "captionText", _s_set_captionText); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "captionImage", _s_set_captionImage); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "placeholder", _s_set_placeholder); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "itemText", _s_set_itemText); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "itemImage", _s_set_itemImage); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "options", _s_set_options); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onValueChanged", _s_set_onValueChanged); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "alphaFadeSpeed", _s_set_alphaFadeSpeed); + 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) + { + return LuaAPI.luaL_error(L, "TMPro.TMP_Dropdown does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetValueWithoutNotify(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + + + + { + int _input = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetValueWithoutNotify( _input ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RefreshShownValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RefreshShownValue( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddOptions(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.List _options = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.AddOptions( _options ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.List _options = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.AddOptions( _options ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.List _options = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.AddOptions( _options ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to TMPro.TMP_Dropdown.AddOptions!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearOptions(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearOptions( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerClick(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerClick( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnSubmit(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.BaseEventData _eventData = (UnityEngine.EventSystems.BaseEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.BaseEventData)); + + gen_to_be_invoked.OnSubmit( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnCancel(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.BaseEventData _eventData = (UnityEngine.EventSystems.BaseEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.BaseEventData)); + + gen_to_be_invoked.OnCancel( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Show(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Show( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Hide(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Hide( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_template(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.template); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_captionText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.captionText); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_captionImage(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.captionImage); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_placeholder(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.placeholder); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_itemText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.itemText); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_itemImage(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.itemImage); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_options(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.options); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onValueChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onValueChanged); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_alphaFadeSpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.alphaFadeSpeed); + } 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); + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(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_IsExpanded(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsExpanded); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_template(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.template = (UnityEngine.RectTransform)translator.GetObject(L, 2, typeof(UnityEngine.RectTransform)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_captionText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.captionText = (TMPro.TMP_Text)translator.GetObject(L, 2, typeof(TMPro.TMP_Text)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_captionImage(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.captionImage = (UnityEngine.UI.Image)translator.GetObject(L, 2, typeof(UnityEngine.UI.Image)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_placeholder(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.placeholder = (UnityEngine.UI.Graphic)translator.GetObject(L, 2, typeof(UnityEngine.UI.Graphic)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_itemText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.itemText = (TMPro.TMP_Text)translator.GetObject(L, 2, typeof(TMPro.TMP_Text)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_itemImage(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.itemImage = (UnityEngine.UI.Image)translator.GetObject(L, 2, typeof(UnityEngine.UI.Image)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_options(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.options = (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; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_onValueChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onValueChanged = (TMPro.TMP_Dropdown.DropdownEvent)translator.GetObject(L, 2, typeof(TMPro.TMP_Dropdown.DropdownEvent)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_alphaFadeSpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.alphaFadeSpeed = (float)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_value(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Dropdown gen_to_be_invoked = (TMPro.TMP_Dropdown)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.value = 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/TMPro_TMP_Dropdown_DropdownEventWrap.cs b/Assets/XLua/Gen/TMPro_TMP_Dropdown_DropdownEventWrap.cs new file mode 100644 index 000000000..8fa87819e --- /dev/null +++ b/Assets/XLua/Gen/TMPro_TMP_Dropdown_DropdownEventWrap.cs @@ -0,0 +1,84 @@ +#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 TMProTMP_DropdownDropdownEventWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(TMPro.TMP_Dropdown.DropdownEvent); + 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) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new TMPro.TMP_Dropdown.DropdownEvent(); + 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 TMPro.TMP_Dropdown.DropdownEvent constructor!"); + + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/TMPro_TMP_Dropdown_OptionDataListWrap.cs b/Assets/XLua/Gen/TMPro_TMP_Dropdown_OptionDataListWrap.cs new file mode 100644 index 000000000..9f689fb82 --- /dev/null +++ b/Assets/XLua/Gen/TMPro_TMP_Dropdown_OptionDataListWrap.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 TMProTMP_DropdownOptionDataListWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(TMPro.TMP_Dropdown.OptionDataList); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 1, 1); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "options", _g_get_options); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "options", _s_set_options); + + + 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 TMPro.TMP_Dropdown.OptionDataList(); + 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 TMPro.TMP_Dropdown.OptionDataList constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_options(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Dropdown.OptionDataList gen_to_be_invoked = (TMPro.TMP_Dropdown.OptionDataList)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.options); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_options(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Dropdown.OptionDataList gen_to_be_invoked = (TMPro.TMP_Dropdown.OptionDataList)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.options = (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/TMPro_TMP_Dropdown_OptionDataWrap.cs b/Assets/XLua/Gen/TMPro_TMP_Dropdown_OptionDataWrap.cs new file mode 100644 index 000000000..d3a0a78be --- /dev/null +++ b/Assets/XLua/Gen/TMPro_TMP_Dropdown_OptionDataWrap.cs @@ -0,0 +1,174 @@ +#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 TMProTMP_DropdownOptionDataWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(TMPro.TMP_Dropdown.OptionData); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 2); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "text", _g_get_text); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "image", _g_get_image); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "text", _s_set_text); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "image", _s_set_image); + + + 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 TMPro.TMP_Dropdown.OptionData(); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _text = LuaAPI.lua_tostring(L, 2); + + var gen_ret = new TMPro.TMP_Dropdown.OptionData(_text); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && translator.Assignable(L, 2)) + { + UnityEngine.Sprite _image = (UnityEngine.Sprite)translator.GetObject(L, 2, typeof(UnityEngine.Sprite)); + + var gen_ret = new TMPro.TMP_Dropdown.OptionData(_image); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 3 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING) && translator.Assignable(L, 3)) + { + string _text = LuaAPI.lua_tostring(L, 2); + UnityEngine.Sprite _image = (UnityEngine.Sprite)translator.GetObject(L, 3, typeof(UnityEngine.Sprite)); + + var gen_ret = new TMPro.TMP_Dropdown.OptionData(_text, _image); + 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 TMPro.TMP_Dropdown.OptionData constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_text(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Dropdown.OptionData gen_to_be_invoked = (TMPro.TMP_Dropdown.OptionData)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.text); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_image(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Dropdown.OptionData gen_to_be_invoked = (TMPro.TMP_Dropdown.OptionData)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.image); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_text(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Dropdown.OptionData gen_to_be_invoked = (TMPro.TMP_Dropdown.OptionData)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.text = 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_image(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Dropdown.OptionData gen_to_be_invoked = (TMPro.TMP_Dropdown.OptionData)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.image = (UnityEngine.Sprite)translator.GetObject(L, 2, typeof(UnityEngine.Sprite)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/TMPro_TMP_FontAssetWrap.cs b/Assets/XLua/Gen/TMPro_TMP_FontAssetWrap.cs new file mode 100644 index 000000000..5e6587523 --- /dev/null +++ b/Assets/XLua/Gen/TMPro_TMP_FontAssetWrap.cs @@ -0,0 +1,1287 @@ +#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; +using BF; + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class TMProTMP_FontAssetWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(TMPro.TMP_FontAsset); + Utils.BeginObjectRegister(type, L, translator, 0, 8, 27, 13); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ReadFontAssetDefinition", _m_ReadFontAssetDefinition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasCharacter", _m_HasCharacter); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasCharacters", _m_HasCharacters); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryAddCharacters", _m_TryAddCharacters); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearFontAssetData", _m_ClearFontAssetData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTMPCharacter", _m_GetTMPCharacter); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearTMPCharacter", _m_ClearTMPCharacter); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddTMPCharacter", _m_AddTMPCharacter); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "version", _g_get_version); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sourceFontFile", _g_get_sourceFontFile); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "atlasPopulationMode", _g_get_atlasPopulationMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "faceInfo", _g_get_faceInfo); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "glyphTable", _g_get_glyphTable); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "glyphLookupTable", _g_get_glyphLookupTable); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "characterTable", _g_get_characterTable); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "characterLookupTable", _g_get_characterLookupTable); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "atlasTexture", _g_get_atlasTexture); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "atlasTextures", _g_get_atlasTextures); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "atlasTextureCount", _g_get_atlasTextureCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isMultiAtlasTexturesEnabled", _g_get_isMultiAtlasTexturesEnabled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "atlasWidth", _g_get_atlasWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "atlasHeight", _g_get_atlasHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "atlasPadding", _g_get_atlasPadding); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "atlasRenderMode", _g_get_atlasRenderMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fontFeatureTable", _g_get_fontFeatureTable); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fallbackFontAssetTable", _g_get_fallbackFontAssetTable); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "creationSettings", _g_get_creationSettings); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fontWeightTable", _g_get_fontWeightTable); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "atlas", _g_get_atlas); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "normalStyle", _g_get_normalStyle); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "normalSpacingOffset", _g_get_normalSpacingOffset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "boldStyle", _g_get_boldStyle); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "boldSpacing", _g_get_boldSpacing); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "italicStyle", _g_get_italicStyle); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "tabSize", _g_get_tabSize); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "atlasPopulationMode", _s_set_atlasPopulationMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "faceInfo", _s_set_faceInfo); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "atlasTextures", _s_set_atlasTextures); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "isMultiAtlasTexturesEnabled", _s_set_isMultiAtlasTexturesEnabled); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fallbackFontAssetTable", _s_set_fallbackFontAssetTable); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "creationSettings", _s_set_creationSettings); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "atlas", _s_set_atlas); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "normalStyle", _s_set_normalStyle); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "normalSpacingOffset", _s_set_normalSpacingOffset); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "boldStyle", _s_set_boldStyle); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "boldSpacing", _s_set_boldSpacing); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "italicStyle", _s_set_italicStyle); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "tabSize", _s_set_tabSize); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 4, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CreateFontAsset", _m_CreateFontAsset_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetCharacters", _m_GetCharacters_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetCharactersArray", _m_GetCharactersArray_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 TMPro.TMP_FontAsset(); + 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 TMPro.TMP_FontAsset constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CreateFontAsset_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + UnityEngine.Font _font = (UnityEngine.Font)translator.GetObject(L, 1, typeof(UnityEngine.Font)); + + var gen_ret = TMPro.TMP_FontAsset.CreateFontAsset( _font ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 8&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 8)) + { + UnityEngine.Font _font = (UnityEngine.Font)translator.GetObject(L, 1, typeof(UnityEngine.Font)); + int _samplingPointSize = LuaAPI.xlua_tointeger(L, 2); + int _atlasPadding = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.TextCore.LowLevel.GlyphRenderMode _renderMode;translator.Get(L, 4, out _renderMode); + int _atlasWidth = LuaAPI.xlua_tointeger(L, 5); + int _atlasHeight = LuaAPI.xlua_tointeger(L, 6); + TMPro.AtlasPopulationMode _atlasPopulationMode;translator.Get(L, 7, out _atlasPopulationMode); + bool _enableMultiAtlasSupport = LuaAPI.lua_toboolean(L, 8); + + var gen_ret = TMPro.TMP_FontAsset.CreateFontAsset( _font, _samplingPointSize, _atlasPadding, _renderMode, _atlasWidth, _atlasHeight, _atlasPopulationMode, _enableMultiAtlasSupport ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 7&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)) + { + UnityEngine.Font _font = (UnityEngine.Font)translator.GetObject(L, 1, typeof(UnityEngine.Font)); + int _samplingPointSize = LuaAPI.xlua_tointeger(L, 2); + int _atlasPadding = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.TextCore.LowLevel.GlyphRenderMode _renderMode;translator.Get(L, 4, out _renderMode); + int _atlasWidth = LuaAPI.xlua_tointeger(L, 5); + int _atlasHeight = LuaAPI.xlua_tointeger(L, 6); + TMPro.AtlasPopulationMode _atlasPopulationMode;translator.Get(L, 7, out _atlasPopulationMode); + + var gen_ret = TMPro.TMP_FontAsset.CreateFontAsset( _font, _samplingPointSize, _atlasPadding, _renderMode, _atlasWidth, _atlasHeight, _atlasPopulationMode ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Font _font = (UnityEngine.Font)translator.GetObject(L, 1, typeof(UnityEngine.Font)); + int _samplingPointSize = LuaAPI.xlua_tointeger(L, 2); + int _atlasPadding = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.TextCore.LowLevel.GlyphRenderMode _renderMode;translator.Get(L, 4, out _renderMode); + int _atlasWidth = LuaAPI.xlua_tointeger(L, 5); + int _atlasHeight = LuaAPI.xlua_tointeger(L, 6); + + var gen_ret = TMPro.TMP_FontAsset.CreateFontAsset( _font, _samplingPointSize, _atlasPadding, _renderMode, _atlasWidth, _atlasHeight ); + 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 TMPro.TMP_FontAsset.CreateFontAsset!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ReadFontAssetDefinition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ReadFontAssetDefinition( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasCharacter(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _character = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.HasCharacter( _character ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + char _character = (char)LuaAPI.xlua_tointeger(L, 2); + bool _searchFallbacks = LuaAPI.lua_toboolean(L, 3); + bool _tryAddCharacter = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.HasCharacter( _character, _searchFallbacks, _tryAddCharacter ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + char _character = (char)LuaAPI.xlua_tointeger(L, 2); + bool _searchFallbacks = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.HasCharacter( _character, _searchFallbacks ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + char _character = (char)LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.HasCharacter( _character ); + LuaAPI.lua_pushboolean(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 TMPro.TMP_FontAsset.HasCharacter!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasCharacters(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _text = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.HasCharacters( _text ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _text = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.List _missingCharacters; + + var gen_ret = gen_to_be_invoked.HasCharacters( _text, out _missingCharacters ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _missingCharacters); + + + + + return 2; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + string _text = LuaAPI.lua_tostring(L, 2); + uint[] _missingCharacters; + bool _searchFallbacks = LuaAPI.lua_toboolean(L, 3); + bool _tryAddCharacter = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.HasCharacters( _text, out _missingCharacters, _searchFallbacks, _tryAddCharacter ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _missingCharacters); + + + + + return 2; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + string _text = LuaAPI.lua_tostring(L, 2); + uint[] _missingCharacters; + bool _searchFallbacks = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.HasCharacters( _text, out _missingCharacters, _searchFallbacks ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _missingCharacters); + + + + + return 2; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _text = LuaAPI.lua_tostring(L, 2); + uint[] _missingCharacters; + + var gen_ret = gen_to_be_invoked.HasCharacters( _text, out _missingCharacters ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _missingCharacters); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to TMPro.TMP_FontAsset.HasCharacters!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetCharacters_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + TMPro.TMP_FontAsset _fontAsset = (TMPro.TMP_FontAsset)translator.GetObject(L, 1, typeof(TMPro.TMP_FontAsset)); + + var gen_ret = TMPro.TMP_FontAsset.GetCharacters( _fontAsset ); + 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 _m_GetCharactersArray_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + TMPro.TMP_FontAsset _fontAsset = (TMPro.TMP_FontAsset)translator.GetObject(L, 1, typeof(TMPro.TMP_FontAsset)); + + var gen_ret = TMPro.TMP_FontAsset.GetCharactersArray( _fontAsset ); + 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_TryAddCharacters(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + uint[] _unicodes = (uint[])translator.GetObject(L, 2, typeof(uint[])); + bool _includeFontFeatures = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.TryAddCharacters( _unicodes, _includeFontFeatures ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + uint[] _unicodes = (uint[])translator.GetObject(L, 2, typeof(uint[])); + + var gen_ret = gen_to_be_invoked.TryAddCharacters( _unicodes ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + string _characters = LuaAPI.lua_tostring(L, 2); + bool _includeFontFeatures = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.TryAddCharacters( _characters, _includeFontFeatures ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _characters = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.TryAddCharacters( _characters ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + uint[] _unicodes = (uint[])translator.GetObject(L, 2, typeof(uint[])); + uint[] _missingUnicodes; + bool _includeFontFeatures = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.TryAddCharacters( _unicodes, out _missingUnicodes, _includeFontFeatures ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _missingUnicodes); + + + + + return 2; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + uint[] _unicodes = (uint[])translator.GetObject(L, 2, typeof(uint[])); + uint[] _missingUnicodes; + + var gen_ret = gen_to_be_invoked.TryAddCharacters( _unicodes, out _missingUnicodes ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _missingUnicodes); + + + + + return 2; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + string _characters = LuaAPI.lua_tostring(L, 2); + string _missingCharacters; + bool _includeFontFeatures = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.TryAddCharacters( _characters, out _missingCharacters, _includeFontFeatures ); + LuaAPI.lua_pushboolean(L, gen_ret); + LuaAPI.lua_pushstring(L, _missingCharacters); + + + + + return 2; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _characters = LuaAPI.lua_tostring(L, 2); + string _missingCharacters; + + var gen_ret = gen_to_be_invoked.TryAddCharacters( _characters, out _missingCharacters ); + LuaAPI.lua_pushboolean(L, gen_ret); + LuaAPI.lua_pushstring(L, _missingCharacters); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to TMPro.TMP_FontAsset.TryAddCharacters!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearFontAssetData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _setAtlasSizeToZero = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.ClearFontAssetData( _setAtlasSizeToZero ); + + + + return 0; + } + if(gen_param_count == 1) + { + + gen_to_be_invoked.ClearFontAssetData( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to TMPro.TMP_FontAsset.ClearFontAssetData!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetTMPCharacter(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + + + + { + uint _index = LuaAPI.xlua_touint(L, 2); + + var gen_ret = gen_to_be_invoked.GetTMPCharacter( _index ); + 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_ClearTMPCharacter(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearTMPCharacter( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddTMPCharacter(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + + + + { + uint _index = LuaAPI.xlua_touint(L, 2); + TMPro.TMP_Character _character = (TMPro.TMP_Character)translator.GetObject(L, 3, typeof(TMPro.TMP_Character)); + + gen_to_be_invoked.AddTMPCharacter( _index, _character ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_version(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.version); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sourceFontFile(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.sourceFontFile); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_atlasPopulationMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.atlasPopulationMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_faceInfo(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.faceInfo); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_glyphTable(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.glyphTable); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_glyphLookupTable(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.glyphLookupTable); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_characterTable(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.characterTable); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_characterLookupTable(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.characterLookupTable); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_atlasTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.atlasTexture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_atlasTextures(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.atlasTextures); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_atlasTextureCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.atlasTextureCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isMultiAtlasTexturesEnabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isMultiAtlasTexturesEnabled); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_atlasWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.atlasWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_atlasHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.atlasHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_atlasPadding(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.atlasPadding); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_atlasRenderMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.atlasRenderMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fontFeatureTable(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.fontFeatureTable); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fallbackFontAssetTable(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.fallbackFontAssetTable); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_creationSettings(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.creationSettings); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fontWeightTable(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.fontWeightTable); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_atlas(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.atlas); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_normalStyle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.normalStyle); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_normalSpacingOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.normalSpacingOffset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_boldStyle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.boldStyle); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_boldSpacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.boldSpacing); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_italicStyle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.italicStyle); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_tabSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.tabSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_atlasPopulationMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + TMPro.AtlasPopulationMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.atlasPopulationMode = 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_faceInfo(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + UnityEngine.TextCore.FaceInfo gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.faceInfo = 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_atlasTextures(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.atlasTextures = (UnityEngine.Texture2D[])translator.GetObject(L, 2, typeof(UnityEngine.Texture2D[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_isMultiAtlasTexturesEnabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.isMultiAtlasTexturesEnabled = 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_fallbackFontAssetTable(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.fallbackFontAssetTable = (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; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_creationSettings(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + TMPro.FontAssetCreationSettings gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.creationSettings = 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_atlas(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.atlas = (UnityEngine.Texture2D)translator.GetObject(L, 2, typeof(UnityEngine.Texture2D)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_normalStyle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.normalStyle = (float)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_normalSpacingOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.normalSpacingOffset = (float)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_boldStyle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.boldStyle = (float)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_boldSpacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.boldSpacing = (float)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_italicStyle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.italicStyle = (byte)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_tabSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_FontAsset gen_to_be_invoked = (TMPro.TMP_FontAsset)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.tabSize = (byte)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/TMPro_TMP_InputFieldWrap.cs b/Assets/XLua/Gen/TMPro_TMP_InputFieldWrap.cs new file mode 100644 index 000000000..2e9e3f397 --- /dev/null +++ b/Assets/XLua/Gen/TMPro_TMP_InputFieldWrap.cs @@ -0,0 +1,2438 @@ +#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 TMProTMP_InputFieldWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(TMPro.TMP_InputField); + Utils.BeginObjectRegister(type, L, translator, 0, 28, 55, 45); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTextWithoutNotify", _m_SetTextWithoutNotify); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "MoveTextEnd", _m_MoveTextEnd); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "MoveTextStart", _m_MoveTextStart); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "MoveToEndOfLine", _m_MoveToEndOfLine); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "MoveToStartOfLine", _m_MoveToStartOfLine); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBeginDrag", _m_OnBeginDrag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnDrag", _m_OnDrag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnEndDrag", _m_OnEndDrag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerDown", _m_OnPointerDown); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ProcessEvent", _m_ProcessEvent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnUpdateSelected", _m_OnUpdateSelected); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnScroll", _m_OnScroll); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ForceLabelUpdate", _m_ForceLabelUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Rebuild", _m_Rebuild); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LayoutComplete", _m_LayoutComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GraphicUpdateComplete", _m_GraphicUpdateComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ActivateInputField", _m_ActivateInputField); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnSelect", _m_OnSelect); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerClick", _m_OnPointerClick); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnControlClick", _m_OnControlClick); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ReleaseSelection", _m_ReleaseSelection); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DeactivateInputField", _m_DeactivateInputField); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnDeselect", _m_OnDeselect); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnSubmit", _m_OnSubmit); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CalculateLayoutInputHorizontal", _m_CalculateLayoutInputHorizontal); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CalculateLayoutInputVertical", _m_CalculateLayoutInputVertical); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetGlobalPointSize", _m_SetGlobalPointSize); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetGlobalFontAsset", _m_SetGlobalFontAsset); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "shouldHideMobileInput", _g_get_shouldHideMobileInput); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "shouldHideSoftKeyboard", _g_get_shouldHideSoftKeyboard); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "text", _g_get_text); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isFocused", _g_get_isFocused); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "caretBlinkRate", _g_get_caretBlinkRate); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "caretWidth", _g_get_caretWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "textViewport", _g_get_textViewport); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "textComponent", _g_get_textComponent); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "placeholder", _g_get_placeholder); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "verticalScrollbar", _g_get_verticalScrollbar); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "scrollSensitivity", _g_get_scrollSensitivity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "caretColor", _g_get_caretColor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "customCaretColor", _g_get_customCaretColor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "selectionColor", _g_get_selectionColor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onEndEdit", _g_get_onEndEdit); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onSubmit", _g_get_onSubmit); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onSelect", _g_get_onSelect); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onDeselect", _g_get_onDeselect); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onTextSelection", _g_get_onTextSelection); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onEndTextSelection", _g_get_onEndTextSelection); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onValueChanged", _g_get_onValueChanged); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onTouchScreenKeyboardStatusChanged", _g_get_onTouchScreenKeyboardStatusChanged); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onValidateInput", _g_get_onValidateInput); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "characterLimit", _g_get_characterLimit); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "pointSize", _g_get_pointSize); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fontAsset", _g_get_fontAsset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onFocusSelectAll", _g_get_onFocusSelectAll); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "resetOnDeActivation", _g_get_resetOnDeActivation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "restoreOriginalTextOnEscape", _g_get_restoreOriginalTextOnEscape); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isRichTextEditingAllowed", _g_get_isRichTextEditingAllowed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "contentType", _g_get_contentType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lineType", _g_get_lineType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lineLimit", _g_get_lineLimit); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "inputType", _g_get_inputType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "keyboardType", _g_get_keyboardType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "characterValidation", _g_get_characterValidation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "inputValidator", _g_get_inputValidator); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "readOnly", _g_get_readOnly); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "richText", _g_get_richText); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "multiLine", _g_get_multiLine); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "asteriskChar", _g_get_asteriskChar); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "wasCanceled", _g_get_wasCanceled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "caretPosition", _g_get_caretPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "selectionAnchorPosition", _g_get_selectionAnchorPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "selectionFocusPosition", _g_get_selectionFocusPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "stringPosition", _g_get_stringPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "selectionStringAnchorPosition", _g_get_selectionStringAnchorPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "selectionStringFocusPosition", _g_get_selectionStringFocusPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "minWidth", _g_get_minWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preferredWidth", _g_get_preferredWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "flexibleWidth", _g_get_flexibleWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "minHeight", _g_get_minHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preferredHeight", _g_get_preferredHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "flexibleHeight", _g_get_flexibleHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "layoutPriority", _g_get_layoutPriority); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "shouldHideMobileInput", _s_set_shouldHideMobileInput); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "shouldHideSoftKeyboard", _s_set_shouldHideSoftKeyboard); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "text", _s_set_text); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "caretBlinkRate", _s_set_caretBlinkRate); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "caretWidth", _s_set_caretWidth); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "textViewport", _s_set_textViewport); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "textComponent", _s_set_textComponent); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "placeholder", _s_set_placeholder); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "verticalScrollbar", _s_set_verticalScrollbar); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "scrollSensitivity", _s_set_scrollSensitivity); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "caretColor", _s_set_caretColor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "customCaretColor", _s_set_customCaretColor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "selectionColor", _s_set_selectionColor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onEndEdit", _s_set_onEndEdit); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onSubmit", _s_set_onSubmit); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onSelect", _s_set_onSelect); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onDeselect", _s_set_onDeselect); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onTextSelection", _s_set_onTextSelection); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onEndTextSelection", _s_set_onEndTextSelection); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onValueChanged", _s_set_onValueChanged); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onTouchScreenKeyboardStatusChanged", _s_set_onTouchScreenKeyboardStatusChanged); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onValidateInput", _s_set_onValidateInput); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "characterLimit", _s_set_characterLimit); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "pointSize", _s_set_pointSize); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fontAsset", _s_set_fontAsset); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onFocusSelectAll", _s_set_onFocusSelectAll); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "resetOnDeActivation", _s_set_resetOnDeActivation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "restoreOriginalTextOnEscape", _s_set_restoreOriginalTextOnEscape); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "isRichTextEditingAllowed", _s_set_isRichTextEditingAllowed); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "contentType", _s_set_contentType); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "lineType", _s_set_lineType); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "lineLimit", _s_set_lineLimit); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "inputType", _s_set_inputType); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "keyboardType", _s_set_keyboardType); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "characterValidation", _s_set_characterValidation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "inputValidator", _s_set_inputValidator); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "readOnly", _s_set_readOnly); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "richText", _s_set_richText); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "asteriskChar", _s_set_asteriskChar); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "caretPosition", _s_set_caretPosition); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "selectionAnchorPosition", _s_set_selectionAnchorPosition); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "selectionFocusPosition", _s_set_selectionFocusPosition); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "stringPosition", _s_set_stringPosition); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "selectionStringAnchorPosition", _s_set_selectionStringAnchorPosition); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "selectionStringFocusPosition", _s_set_selectionStringFocusPosition); + + + 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, "TMPro.TMP_InputField does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTextWithoutNotify(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + + + + { + string _input = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SetTextWithoutNotify( _input ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_MoveTextEnd(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + + + + { + bool _shift = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.MoveTextEnd( _shift ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_MoveTextStart(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + + + + { + bool _shift = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.MoveTextStart( _shift ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_MoveToEndOfLine(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + + + + { + bool _shift = LuaAPI.lua_toboolean(L, 2); + bool _ctrl = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.MoveToEndOfLine( _shift, _ctrl ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_MoveToStartOfLine(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + + + + { + bool _shift = LuaAPI.lua_toboolean(L, 2); + bool _ctrl = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.MoveToStartOfLine( _shift, _ctrl ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnBeginDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnBeginDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnEndDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnEndDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerDown(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerDown( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ProcessEvent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Event _e = (UnityEngine.Event)translator.GetObject(L, 2, typeof(UnityEngine.Event)); + + gen_to_be_invoked.ProcessEvent( _e ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnUpdateSelected(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.BaseEventData _eventData = (UnityEngine.EventSystems.BaseEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.BaseEventData)); + + gen_to_be_invoked.OnUpdateSelected( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnScroll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnScroll( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ForceLabelUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ForceLabelUpdate( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Rebuild(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.UI.CanvasUpdate _update;translator.Get(L, 2, out _update); + + gen_to_be_invoked.Rebuild( _update ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LayoutComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.LayoutComplete( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GraphicUpdateComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.GraphicUpdateComplete( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ActivateInputField(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ActivateInputField( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnSelect(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.BaseEventData _eventData = (UnityEngine.EventSystems.BaseEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.BaseEventData)); + + gen_to_be_invoked.OnSelect( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerClick(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerClick( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnControlClick(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.OnControlClick( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ReleaseSelection(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ReleaseSelection( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DeactivateInputField(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _clearSelection = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.DeactivateInputField( _clearSelection ); + + + + return 0; + } + if(gen_param_count == 1) + { + + gen_to_be_invoked.DeactivateInputField( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to TMPro.TMP_InputField.DeactivateInputField!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnDeselect(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.BaseEventData _eventData = (UnityEngine.EventSystems.BaseEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.BaseEventData)); + + gen_to_be_invoked.OnDeselect( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnSubmit(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.BaseEventData _eventData = (UnityEngine.EventSystems.BaseEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.BaseEventData)); + + gen_to_be_invoked.OnSubmit( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalculateLayoutInputHorizontal(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CalculateLayoutInputHorizontal( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalculateLayoutInputVertical(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CalculateLayoutInputVertical( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetGlobalPointSize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + + + + { + float _pointSize = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.SetGlobalPointSize( _pointSize ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetGlobalFontAsset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + + + + { + TMPro.TMP_FontAsset _fontAsset = (TMPro.TMP_FontAsset)translator.GetObject(L, 2, typeof(TMPro.TMP_FontAsset)); + + gen_to_be_invoked.SetGlobalFontAsset( _fontAsset ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_shouldHideMobileInput(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.shouldHideMobileInput); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_shouldHideSoftKeyboard(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.shouldHideSoftKeyboard); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_text(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.text); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isFocused(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isFocused); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_caretBlinkRate(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.caretBlinkRate); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_caretWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.caretWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_textViewport(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.textViewport); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_textComponent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.textComponent); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_placeholder(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.placeholder); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_verticalScrollbar(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.verticalScrollbar); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_scrollSensitivity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.scrollSensitivity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_caretColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineColor(L, gen_to_be_invoked.caretColor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_customCaretColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.customCaretColor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_selectionColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineColor(L, gen_to_be_invoked.selectionColor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onEndEdit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onEndEdit); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onSubmit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onSubmit); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onSelect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onSelect); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onDeselect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onDeselect); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onTextSelection(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onTextSelection); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onEndTextSelection(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onEndTextSelection); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onValueChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onValueChanged); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onTouchScreenKeyboardStatusChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onTouchScreenKeyboardStatusChanged); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onValidateInput(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onValidateInput); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_characterLimit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.characterLimit); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_pointSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.pointSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fontAsset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.fontAsset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onFocusSelectAll(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.onFocusSelectAll); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_resetOnDeActivation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.resetOnDeActivation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_restoreOriginalTextOnEscape(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.restoreOriginalTextOnEscape); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isRichTextEditingAllowed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isRichTextEditingAllowed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_contentType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + translator.PushTMProTMP_InputFieldContentType(L, gen_to_be_invoked.contentType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lineType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + translator.PushTMProTMP_InputFieldLineType(L, gen_to_be_invoked.lineType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lineLimit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.lineLimit); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_inputType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + translator.PushTMProTMP_InputFieldInputType(L, gen_to_be_invoked.inputType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_keyboardType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.keyboardType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_characterValidation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + translator.PushTMProTMP_InputFieldCharacterValidation(L, gen_to_be_invoked.characterValidation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_inputValidator(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.inputValidator); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_readOnly(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.readOnly); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_richText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.richText); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_multiLine(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.multiLine); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_asteriskChar(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.asteriskChar); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_wasCanceled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.wasCanceled); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_caretPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.caretPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_selectionAnchorPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.selectionAnchorPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_selectionFocusPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.selectionFocusPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_stringPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.stringPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_selectionStringAnchorPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.selectionStringAnchorPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_selectionStringFocusPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.selectionStringFocusPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_minWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.minWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preferredWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.preferredWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_flexibleWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.flexibleWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_minHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.minHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preferredHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.preferredHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_flexibleHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.flexibleHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_layoutPriority(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.layoutPriority); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_shouldHideMobileInput(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.shouldHideMobileInput = 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_shouldHideSoftKeyboard(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.shouldHideSoftKeyboard = 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_text(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.text = 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_caretBlinkRate(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.caretBlinkRate = (float)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_caretWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.caretWidth = 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_textViewport(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.textViewport = (UnityEngine.RectTransform)translator.GetObject(L, 2, typeof(UnityEngine.RectTransform)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_textComponent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.textComponent = (TMPro.TMP_Text)translator.GetObject(L, 2, typeof(TMPro.TMP_Text)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_placeholder(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.placeholder = (UnityEngine.UI.Graphic)translator.GetObject(L, 2, typeof(UnityEngine.UI.Graphic)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_verticalScrollbar(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.verticalScrollbar = (UnityEngine.UI.Scrollbar)translator.GetObject(L, 2, typeof(UnityEngine.UI.Scrollbar)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_scrollSensitivity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.scrollSensitivity = (float)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_caretColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + UnityEngine.Color gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.caretColor = 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_customCaretColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.customCaretColor = 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_selectionColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + UnityEngine.Color gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.selectionColor = 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_onEndEdit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onEndEdit = (TMPro.TMP_InputField.SubmitEvent)translator.GetObject(L, 2, typeof(TMPro.TMP_InputField.SubmitEvent)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_onSubmit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onSubmit = (TMPro.TMP_InputField.SubmitEvent)translator.GetObject(L, 2, typeof(TMPro.TMP_InputField.SubmitEvent)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_onSelect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onSelect = (TMPro.TMP_InputField.SelectionEvent)translator.GetObject(L, 2, typeof(TMPro.TMP_InputField.SelectionEvent)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_onDeselect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onDeselect = (TMPro.TMP_InputField.SelectionEvent)translator.GetObject(L, 2, typeof(TMPro.TMP_InputField.SelectionEvent)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_onTextSelection(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onTextSelection = (TMPro.TMP_InputField.TextSelectionEvent)translator.GetObject(L, 2, typeof(TMPro.TMP_InputField.TextSelectionEvent)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_onEndTextSelection(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onEndTextSelection = (TMPro.TMP_InputField.TextSelectionEvent)translator.GetObject(L, 2, typeof(TMPro.TMP_InputField.TextSelectionEvent)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_onValueChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onValueChanged = (TMPro.TMP_InputField.OnChangeEvent)translator.GetObject(L, 2, typeof(TMPro.TMP_InputField.OnChangeEvent)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_onTouchScreenKeyboardStatusChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onTouchScreenKeyboardStatusChanged = (TMPro.TMP_InputField.TouchScreenKeyboardEvent)translator.GetObject(L, 2, typeof(TMPro.TMP_InputField.TouchScreenKeyboardEvent)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_onValidateInput(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onValidateInput = translator.GetDelegate(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_characterLimit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.characterLimit = 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_pointSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.pointSize = (float)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_fontAsset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.fontAsset = (TMPro.TMP_FontAsset)translator.GetObject(L, 2, typeof(TMPro.TMP_FontAsset)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_onFocusSelectAll(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onFocusSelectAll = 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_resetOnDeActivation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.resetOnDeActivation = 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_restoreOriginalTextOnEscape(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.restoreOriginalTextOnEscape = 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_isRichTextEditingAllowed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.isRichTextEditingAllowed = 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_contentType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + TMPro.TMP_InputField.ContentType gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.contentType = 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_lineType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + TMPro.TMP_InputField.LineType gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.lineType = 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_lineLimit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.lineLimit = 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_inputType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + TMPro.TMP_InputField.InputType gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.inputType = 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_keyboardType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + UnityEngine.TouchScreenKeyboardType gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.keyboardType = 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_characterValidation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + TMPro.TMP_InputField.CharacterValidation gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.characterValidation = 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_inputValidator(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.inputValidator = (TMPro.TMP_InputValidator)translator.GetObject(L, 2, typeof(TMPro.TMP_InputValidator)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_readOnly(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.readOnly = 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_richText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.richText = 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_asteriskChar(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.asteriskChar = (char)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_caretPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.caretPosition = 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_selectionAnchorPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.selectionAnchorPosition = 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_selectionFocusPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.selectionFocusPosition = 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_stringPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.stringPosition = 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_selectionStringAnchorPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.selectionStringAnchorPosition = 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_selectionStringFocusPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_InputField gen_to_be_invoked = (TMPro.TMP_InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.selectionStringFocusPosition = 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/TMPro_TMP_InputField_OnChangeEventWrap.cs b/Assets/XLua/Gen/TMPro_TMP_InputField_OnChangeEventWrap.cs new file mode 100644 index 000000000..46783b644 --- /dev/null +++ b/Assets/XLua/Gen/TMPro_TMP_InputField_OnChangeEventWrap.cs @@ -0,0 +1,84 @@ +#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 TMProTMP_InputFieldOnChangeEventWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(TMPro.TMP_InputField.OnChangeEvent); + 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) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new TMPro.TMP_InputField.OnChangeEvent(); + 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 TMPro.TMP_InputField.OnChangeEvent constructor!"); + + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/TMPro_TMP_InputField_SelectionEventWrap.cs b/Assets/XLua/Gen/TMPro_TMP_InputField_SelectionEventWrap.cs new file mode 100644 index 000000000..f3014c864 --- /dev/null +++ b/Assets/XLua/Gen/TMPro_TMP_InputField_SelectionEventWrap.cs @@ -0,0 +1,84 @@ +#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 TMProTMP_InputFieldSelectionEventWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(TMPro.TMP_InputField.SelectionEvent); + 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) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new TMPro.TMP_InputField.SelectionEvent(); + 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 TMPro.TMP_InputField.SelectionEvent constructor!"); + + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/TMPro_TMP_InputField_SubmitEventWrap.cs b/Assets/XLua/Gen/TMPro_TMP_InputField_SubmitEventWrap.cs new file mode 100644 index 000000000..9eab63fe5 --- /dev/null +++ b/Assets/XLua/Gen/TMPro_TMP_InputField_SubmitEventWrap.cs @@ -0,0 +1,84 @@ +#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 TMProTMP_InputFieldSubmitEventWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(TMPro.TMP_InputField.SubmitEvent); + 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) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new TMPro.TMP_InputField.SubmitEvent(); + 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 TMPro.TMP_InputField.SubmitEvent constructor!"); + + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/TMPro_TMP_InputField_TextSelectionEventWrap.cs b/Assets/XLua/Gen/TMPro_TMP_InputField_TextSelectionEventWrap.cs new file mode 100644 index 000000000..ba438230c --- /dev/null +++ b/Assets/XLua/Gen/TMPro_TMP_InputField_TextSelectionEventWrap.cs @@ -0,0 +1,84 @@ +#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 TMProTMP_InputFieldTextSelectionEventWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(TMPro.TMP_InputField.TextSelectionEvent); + 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) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new TMPro.TMP_InputField.TextSelectionEvent(); + 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 TMPro.TMP_InputField.TextSelectionEvent constructor!"); + + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/TMPro_TMP_InputField_TouchScreenKeyboardEventWrap.cs b/Assets/XLua/Gen/TMPro_TMP_InputField_TouchScreenKeyboardEventWrap.cs new file mode 100644 index 000000000..bc12d2254 --- /dev/null +++ b/Assets/XLua/Gen/TMPro_TMP_InputField_TouchScreenKeyboardEventWrap.cs @@ -0,0 +1,84 @@ +#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 TMProTMP_InputFieldTouchScreenKeyboardEventWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(TMPro.TMP_InputField.TouchScreenKeyboardEvent); + 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) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new TMPro.TMP_InputField.TouchScreenKeyboardEvent(); + 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 TMPro.TMP_InputField.TouchScreenKeyboardEvent constructor!"); + + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/TMPro_TMP_TextWrap.cs b/Assets/XLua/Gen/TMPro_TMP_TextWrap.cs new file mode 100644 index 000000000..1e847bff1 --- /dev/null +++ b/Assets/XLua/Gen/TMPro_TMP_TextWrap.cs @@ -0,0 +1,3277 @@ +#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 TMProTMP_TextWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(TMPro.TMP_Text); + Utils.BeginObjectRegister(type, L, translator, 0, 16, 88, 66); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ForceMeshUpdate", _m_ForceMeshUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateGeometry", _m_UpdateGeometry); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateVertexData", _m_UpdateVertexData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetVertices", _m_SetVertices); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateMeshPadding", _m_UpdateMeshPadding); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CrossFadeColor", _m_CrossFadeColor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CrossFadeAlpha", _m_CrossFadeAlpha); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetText", _m_SetText); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetCharArray", _m_SetCharArray); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPreferredValues", _m_GetPreferredValues); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetRenderedValues", _m_GetRenderedValues); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTextInfo", _m_GetTextInfo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ComputeMarginSize", _m_ComputeMarginSize); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearMesh", _m_ClearMesh); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetParsedText", _m_GetParsedText); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPreRenderText", _e_OnPreRenderText); + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "text", _g_get_text); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "textPreprocessor", _g_get_textPreprocessor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isRightToLeftText", _g_get_isRightToLeftText); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "font", _g_get_font); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fontSharedMaterial", _g_get_fontSharedMaterial); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fontSharedMaterials", _g_get_fontSharedMaterials); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fontMaterial", _g_get_fontMaterial); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fontMaterials", _g_get_fontMaterials); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "color", _g_get_color); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "alpha", _g_get_alpha); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enableVertexGradient", _g_get_enableVertexGradient); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "colorGradient", _g_get_colorGradient); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "colorGradientPreset", _g_get_colorGradientPreset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "spriteAsset", _g_get_spriteAsset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "tintAllSprites", _g_get_tintAllSprites); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "styleSheet", _g_get_styleSheet); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "textStyle", _g_get_textStyle); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "overrideColorTags", _g_get_overrideColorTags); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "faceColor", _g_get_faceColor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "outlineColor", _g_get_outlineColor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "outlineWidth", _g_get_outlineWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fontSize", _g_get_fontSize); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fontWeight", _g_get_fontWeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "pixelsPerUnit", _g_get_pixelsPerUnit); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enableAutoSizing", _g_get_enableAutoSizing); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fontSizeMin", _g_get_fontSizeMin); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fontSizeMax", _g_get_fontSizeMax); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fontStyle", _g_get_fontStyle); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isUsingBold", _g_get_isUsingBold); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "horizontalAlignment", _g_get_horizontalAlignment); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "verticalAlignment", _g_get_verticalAlignment); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "alignment", _g_get_alignment); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "characterSpacing", _g_get_characterSpacing); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "wordSpacing", _g_get_wordSpacing); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lineSpacing", _g_get_lineSpacing); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lineSpacingAdjustment", _g_get_lineSpacingAdjustment); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "paragraphSpacing", _g_get_paragraphSpacing); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "characterWidthAdjustment", _g_get_characterWidthAdjustment); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enableWordWrapping", _g_get_enableWordWrapping); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "wordWrappingRatios", _g_get_wordWrappingRatios); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "overflowMode", _g_get_overflowMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isTextOverflowing", _g_get_isTextOverflowing); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "firstOverflowCharacterIndex", _g_get_firstOverflowCharacterIndex); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "linkedTextComponent", _g_get_linkedTextComponent); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isTextTruncated", _g_get_isTextTruncated); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enableKerning", _g_get_enableKerning); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "extraPadding", _g_get_extraPadding); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "richText", _g_get_richText); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "parseCtrlCharacters", _g_get_parseCtrlCharacters); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isOverlay", _g_get_isOverlay); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isOrthographic", _g_get_isOrthographic); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enableCulling", _g_get_enableCulling); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ignoreVisibility", _g_get_ignoreVisibility); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "horizontalMapping", _g_get_horizontalMapping); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "verticalMapping", _g_get_verticalMapping); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mappingUvLineOffset", _g_get_mappingUvLineOffset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "renderMode", _g_get_renderMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "geometrySortingOrder", _g_get_geometrySortingOrder); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isTextObjectScaleStatic", _g_get_isTextObjectScaleStatic); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "vertexBufferAutoSizeReduction", _g_get_vertexBufferAutoSizeReduction); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "firstVisibleCharacter", _g_get_firstVisibleCharacter); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "maxVisibleCharacters", _g_get_maxVisibleCharacters); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "maxVisibleWords", _g_get_maxVisibleWords); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "maxVisibleLines", _g_get_maxVisibleLines); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "useMaxVisibleDescender", _g_get_useMaxVisibleDescender); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "pageToDisplay", _g_get_pageToDisplay); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "margin", _g_get_margin); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "textInfo", _g_get_textInfo); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "havePropertiesChanged", _g_get_havePropertiesChanged); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isUsingLegacyAnimationComponent", _g_get_isUsingLegacyAnimationComponent); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "transform", _g_get_transform); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rectTransform", _g_get_rectTransform); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "autoSizeTextContainer", _g_get_autoSizeTextContainer); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mesh", _g_get_mesh); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isVolumetricText", _g_get_isVolumetricText); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bounds", _g_get_bounds); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "textBounds", _g_get_textBounds); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "flexibleHeight", _g_get_flexibleHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "flexibleWidth", _g_get_flexibleWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "minWidth", _g_get_minWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "minHeight", _g_get_minHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "maxWidth", _g_get_maxWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "maxHeight", _g_get_maxHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preferredWidth", _g_get_preferredWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preferredHeight", _g_get_preferredHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "renderedWidth", _g_get_renderedWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "renderedHeight", _g_get_renderedHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "layoutPriority", _g_get_layoutPriority); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "text", _s_set_text); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "textPreprocessor", _s_set_textPreprocessor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "isRightToLeftText", _s_set_isRightToLeftText); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "font", _s_set_font); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fontSharedMaterial", _s_set_fontSharedMaterial); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fontSharedMaterials", _s_set_fontSharedMaterials); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fontMaterial", _s_set_fontMaterial); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fontMaterials", _s_set_fontMaterials); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "color", _s_set_color); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "alpha", _s_set_alpha); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enableVertexGradient", _s_set_enableVertexGradient); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "colorGradient", _s_set_colorGradient); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "colorGradientPreset", _s_set_colorGradientPreset); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "spriteAsset", _s_set_spriteAsset); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "tintAllSprites", _s_set_tintAllSprites); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "styleSheet", _s_set_styleSheet); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "textStyle", _s_set_textStyle); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "overrideColorTags", _s_set_overrideColorTags); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "faceColor", _s_set_faceColor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "outlineColor", _s_set_outlineColor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "outlineWidth", _s_set_outlineWidth); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fontSize", _s_set_fontSize); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fontWeight", _s_set_fontWeight); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enableAutoSizing", _s_set_enableAutoSizing); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fontSizeMin", _s_set_fontSizeMin); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fontSizeMax", _s_set_fontSizeMax); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fontStyle", _s_set_fontStyle); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "horizontalAlignment", _s_set_horizontalAlignment); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "verticalAlignment", _s_set_verticalAlignment); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "alignment", _s_set_alignment); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "characterSpacing", _s_set_characterSpacing); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "wordSpacing", _s_set_wordSpacing); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "lineSpacing", _s_set_lineSpacing); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "lineSpacingAdjustment", _s_set_lineSpacingAdjustment); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "paragraphSpacing", _s_set_paragraphSpacing); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "characterWidthAdjustment", _s_set_characterWidthAdjustment); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enableWordWrapping", _s_set_enableWordWrapping); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "wordWrappingRatios", _s_set_wordWrappingRatios); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "overflowMode", _s_set_overflowMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "linkedTextComponent", _s_set_linkedTextComponent); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enableKerning", _s_set_enableKerning); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "extraPadding", _s_set_extraPadding); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "richText", _s_set_richText); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "parseCtrlCharacters", _s_set_parseCtrlCharacters); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "isOverlay", _s_set_isOverlay); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "isOrthographic", _s_set_isOrthographic); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enableCulling", _s_set_enableCulling); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ignoreVisibility", _s_set_ignoreVisibility); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "horizontalMapping", _s_set_horizontalMapping); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "verticalMapping", _s_set_verticalMapping); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "mappingUvLineOffset", _s_set_mappingUvLineOffset); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "renderMode", _s_set_renderMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "geometrySortingOrder", _s_set_geometrySortingOrder); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "isTextObjectScaleStatic", _s_set_isTextObjectScaleStatic); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "vertexBufferAutoSizeReduction", _s_set_vertexBufferAutoSizeReduction); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "firstVisibleCharacter", _s_set_firstVisibleCharacter); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "maxVisibleCharacters", _s_set_maxVisibleCharacters); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "maxVisibleWords", _s_set_maxVisibleWords); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "maxVisibleLines", _s_set_maxVisibleLines); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "useMaxVisibleDescender", _s_set_useMaxVisibleDescender); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "pageToDisplay", _s_set_pageToDisplay); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "margin", _s_set_margin); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "havePropertiesChanged", _s_set_havePropertiesChanged); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "isUsingLegacyAnimationComponent", _s_set_isUsingLegacyAnimationComponent); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "autoSizeTextContainer", _s_set_autoSizeTextContainer); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "isVolumetricText", _s_set_isVolumetricText); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 3, 0, 0); + + Utils.RegisterFunc(L, Utils.CLS_IDX, "OnFontAssetRequest", _e_OnFontAssetRequest); + Utils.RegisterFunc(L, Utils.CLS_IDX, "OnSpriteAssetRequest", _e_OnSpriteAssetRequest); + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "TMPro.TMP_Text does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ForceMeshUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + bool _ignoreActiveState = LuaAPI.lua_toboolean(L, 2); + bool _forceTextReparsing = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.ForceMeshUpdate( _ignoreActiveState, _forceTextReparsing ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _ignoreActiveState = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.ForceMeshUpdate( _ignoreActiveState ); + + + + return 0; + } + if(gen_param_count == 1) + { + + gen_to_be_invoked.ForceMeshUpdate( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to TMPro.TMP_Text.ForceMeshUpdate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UpdateGeometry(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + int _index = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.UpdateGeometry( _mesh, _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UpdateVertexData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.UpdateVertexData( ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + TMPro.TMP_VertexDataUpdateFlags _flags;translator.Get(L, 2, out _flags); + + gen_to_be_invoked.UpdateVertexData( _flags ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to TMPro.TMP_Text.UpdateVertexData!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetVertices(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector3[] _vertices = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + + gen_to_be_invoked.SetVertices( _vertices ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UpdateMeshPadding(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.UpdateMeshPadding( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CrossFadeColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Color _targetColor;translator.Get(L, 2, out _targetColor); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _ignoreTimeScale = LuaAPI.lua_toboolean(L, 4); + bool _useAlpha = LuaAPI.lua_toboolean(L, 5); + + gen_to_be_invoked.CrossFadeColor( _targetColor, _duration, _ignoreTimeScale, _useAlpha ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CrossFadeAlpha(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + + + + { + float _alpha = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _ignoreTimeScale = LuaAPI.lua_toboolean(L, 4); + + gen_to_be_invoked.CrossFadeAlpha( _alpha, _duration, _ignoreTimeScale ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetText(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.Text.StringBuilder _sourceText = (System.Text.StringBuilder)translator.GetObject(L, 2, typeof(System.Text.StringBuilder)); + + gen_to_be_invoked.SetText( _sourceText ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + char[] _sourceText = (char[])translator.GetObject(L, 2, typeof(char[])); + + gen_to_be_invoked.SetText( _sourceText ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + string _sourceText = LuaAPI.lua_tostring(L, 2); + bool _syncTextInputBox = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.SetText( _sourceText, _syncTextInputBox ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _sourceText = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SetText( _sourceText ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + string _sourceText = LuaAPI.lua_tostring(L, 2); + float _arg0 = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetText( _sourceText, _arg0 ); + + + + return 0; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + string _sourceText = LuaAPI.lua_tostring(L, 2); + float _arg0 = (float)LuaAPI.lua_tonumber(L, 3); + float _arg1 = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.SetText( _sourceText, _arg0, _arg1 ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + char[] _sourceText = (char[])translator.GetObject(L, 2, typeof(char[])); + int _start = LuaAPI.xlua_tointeger(L, 3); + int _length = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.SetText( _sourceText, _start, _length ); + + + + return 0; + } + if(gen_param_count == 5&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + string _sourceText = LuaAPI.lua_tostring(L, 2); + float _arg0 = (float)LuaAPI.lua_tonumber(L, 3); + float _arg1 = (float)LuaAPI.lua_tonumber(L, 4); + float _arg2 = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.SetText( _sourceText, _arg0, _arg1, _arg2 ); + + + + return 0; + } + if(gen_param_count == 6&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + string _sourceText = LuaAPI.lua_tostring(L, 2); + float _arg0 = (float)LuaAPI.lua_tonumber(L, 3); + float _arg1 = (float)LuaAPI.lua_tonumber(L, 4); + float _arg2 = (float)LuaAPI.lua_tonumber(L, 5); + float _arg3 = (float)LuaAPI.lua_tonumber(L, 6); + + gen_to_be_invoked.SetText( _sourceText, _arg0, _arg1, _arg2, _arg3 ); + + + + return 0; + } + if(gen_param_count == 7&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)) + { + string _sourceText = LuaAPI.lua_tostring(L, 2); + float _arg0 = (float)LuaAPI.lua_tonumber(L, 3); + float _arg1 = (float)LuaAPI.lua_tonumber(L, 4); + float _arg2 = (float)LuaAPI.lua_tonumber(L, 5); + float _arg3 = (float)LuaAPI.lua_tonumber(L, 6); + float _arg4 = (float)LuaAPI.lua_tonumber(L, 7); + + gen_to_be_invoked.SetText( _sourceText, _arg0, _arg1, _arg2, _arg3, _arg4 ); + + + + return 0; + } + if(gen_param_count == 8&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 8)) + { + string _sourceText = LuaAPI.lua_tostring(L, 2); + float _arg0 = (float)LuaAPI.lua_tonumber(L, 3); + float _arg1 = (float)LuaAPI.lua_tonumber(L, 4); + float _arg2 = (float)LuaAPI.lua_tonumber(L, 5); + float _arg3 = (float)LuaAPI.lua_tonumber(L, 6); + float _arg4 = (float)LuaAPI.lua_tonumber(L, 7); + float _arg5 = (float)LuaAPI.lua_tonumber(L, 8); + + gen_to_be_invoked.SetText( _sourceText, _arg0, _arg1, _arg2, _arg3, _arg4, _arg5 ); + + + + return 0; + } + if(gen_param_count == 9&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 8)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 9)) + { + string _sourceText = LuaAPI.lua_tostring(L, 2); + float _arg0 = (float)LuaAPI.lua_tonumber(L, 3); + float _arg1 = (float)LuaAPI.lua_tonumber(L, 4); + float _arg2 = (float)LuaAPI.lua_tonumber(L, 5); + float _arg3 = (float)LuaAPI.lua_tonumber(L, 6); + float _arg4 = (float)LuaAPI.lua_tonumber(L, 7); + float _arg5 = (float)LuaAPI.lua_tonumber(L, 8); + float _arg6 = (float)LuaAPI.lua_tonumber(L, 9); + + gen_to_be_invoked.SetText( _sourceText, _arg0, _arg1, _arg2, _arg3, _arg4, _arg5, _arg6 ); + + + + return 0; + } + if(gen_param_count == 10&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 8)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 9)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 10)) + { + string _sourceText = LuaAPI.lua_tostring(L, 2); + float _arg0 = (float)LuaAPI.lua_tonumber(L, 3); + float _arg1 = (float)LuaAPI.lua_tonumber(L, 4); + float _arg2 = (float)LuaAPI.lua_tonumber(L, 5); + float _arg3 = (float)LuaAPI.lua_tonumber(L, 6); + float _arg4 = (float)LuaAPI.lua_tonumber(L, 7); + float _arg5 = (float)LuaAPI.lua_tonumber(L, 8); + float _arg6 = (float)LuaAPI.lua_tonumber(L, 9); + float _arg7 = (float)LuaAPI.lua_tonumber(L, 10); + + gen_to_be_invoked.SetText( _sourceText, _arg0, _arg1, _arg2, _arg3, _arg4, _arg5, _arg6, _arg7 ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to TMPro.TMP_Text.SetText!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetCharArray(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + char[] _sourceText = (char[])translator.GetObject(L, 2, typeof(char[])); + + gen_to_be_invoked.SetCharArray( _sourceText ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + char[] _sourceText = (char[])translator.GetObject(L, 2, typeof(char[])); + int _start = LuaAPI.xlua_tointeger(L, 3); + int _length = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.SetCharArray( _sourceText, _start, _length ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to TMPro.TMP_Text.SetCharArray!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetPreferredValues(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.GetPreferredValues( ); + translator.PushUnityEngineVector2(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _width = (float)LuaAPI.lua_tonumber(L, 2); + float _height = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.GetPreferredValues( _width, _height ); + translator.PushUnityEngineVector2(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _text = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetPreferredValues( _text ); + translator.PushUnityEngineVector2(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + string _text = LuaAPI.lua_tostring(L, 2); + float _width = (float)LuaAPI.lua_tonumber(L, 3); + float _height = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.GetPreferredValues( _text, _width, _height ); + translator.PushUnityEngineVector2(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 TMPro.TMP_Text.GetPreferredValues!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetRenderedValues(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.GetRenderedValues( ); + translator.PushUnityEngineVector2(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _onlyVisibleCharacters = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.GetRenderedValues( _onlyVisibleCharacters ); + translator.PushUnityEngineVector2(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 TMPro.TMP_Text.GetRenderedValues!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetTextInfo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + + + + { + string _text = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetTextInfo( _text ); + 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_ComputeMarginSize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ComputeMarginSize( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearMesh(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.ClearMesh( ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _uploadGeometry = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.ClearMesh( _uploadGeometry ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to TMPro.TMP_Text.ClearMesh!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetParsedText(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetParsedText( ); + 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_text(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.text); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_textPreprocessor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.textPreprocessor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isRightToLeftText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isRightToLeftText); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_font(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.font); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fontSharedMaterial(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.fontSharedMaterial); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fontSharedMaterials(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.fontSharedMaterials); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fontMaterial(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.fontMaterial); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fontMaterials(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.fontMaterials); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_color(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineColor(L, gen_to_be_invoked.color); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_alpha(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.alpha); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enableVertexGradient(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.enableVertexGradient); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_colorGradient(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.colorGradient); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_colorGradientPreset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.colorGradientPreset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_spriteAsset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.spriteAsset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_tintAllSprites(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.tintAllSprites); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_styleSheet(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.styleSheet); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_textStyle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.textStyle); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_overrideColorTags(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.overrideColorTags); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_faceColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.faceColor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_outlineColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.outlineColor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_outlineWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.outlineWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fontSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.fontSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fontWeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.fontWeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_pixelsPerUnit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.pixelsPerUnit); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enableAutoSizing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.enableAutoSizing); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fontSizeMin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.fontSizeMin); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fontSizeMax(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.fontSizeMax); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fontStyle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.fontStyle); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isUsingBold(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isUsingBold); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_horizontalAlignment(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.horizontalAlignment); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_verticalAlignment(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.verticalAlignment); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_alignment(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.PushTMProTextAlignmentOptions(L, gen_to_be_invoked.alignment); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_characterSpacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.characterSpacing); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_wordSpacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.wordSpacing); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lineSpacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.lineSpacing); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lineSpacingAdjustment(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.lineSpacingAdjustment); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_paragraphSpacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.paragraphSpacing); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_characterWidthAdjustment(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.characterWidthAdjustment); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enableWordWrapping(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.enableWordWrapping); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_wordWrappingRatios(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.wordWrappingRatios); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_overflowMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.overflowMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isTextOverflowing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isTextOverflowing); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_firstOverflowCharacterIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.firstOverflowCharacterIndex); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_linkedTextComponent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.linkedTextComponent); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isTextTruncated(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isTextTruncated); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enableKerning(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.enableKerning); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_extraPadding(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.extraPadding); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_richText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.richText); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_parseCtrlCharacters(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.parseCtrlCharacters); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isOverlay(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isOverlay); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isOrthographic(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isOrthographic); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enableCulling(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.enableCulling); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ignoreVisibility(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.ignoreVisibility); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_horizontalMapping(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.horizontalMapping); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_verticalMapping(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.verticalMapping); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mappingUvLineOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.mappingUvLineOffset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_renderMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.renderMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_geometrySortingOrder(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.geometrySortingOrder); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isTextObjectScaleStatic(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isTextObjectScaleStatic); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_vertexBufferAutoSizeReduction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.vertexBufferAutoSizeReduction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_firstVisibleCharacter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.firstVisibleCharacter); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxVisibleCharacters(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.maxVisibleCharacters); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxVisibleWords(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.maxVisibleWords); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxVisibleLines(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.maxVisibleLines); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_useMaxVisibleDescender(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.useMaxVisibleDescender); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_pageToDisplay(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.pageToDisplay); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_margin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector4(L, gen_to_be_invoked.margin); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_textInfo(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.textInfo); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_havePropertiesChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.havePropertiesChanged); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isUsingLegacyAnimationComponent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isUsingLegacyAnimationComponent); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_transform(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.transform); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rectTransform(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.rectTransform); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_autoSizeTextContainer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.autoSizeTextContainer); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mesh(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.mesh); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isVolumetricText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isVolumetricText); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bounds(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineBounds(L, gen_to_be_invoked.bounds); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_textBounds(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineBounds(L, gen_to_be_invoked.textBounds); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_flexibleHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.flexibleHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_flexibleWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.flexibleWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_minWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.minWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_minHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.minHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.maxWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.maxHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preferredWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.preferredWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preferredHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.preferredHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_renderedWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.renderedWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_renderedHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.renderedHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_layoutPriority(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.layoutPriority); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_text(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.text = 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_textPreprocessor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.textPreprocessor = (TMPro.ITextPreprocessor)translator.GetObject(L, 2, typeof(TMPro.ITextPreprocessor)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_isRightToLeftText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.isRightToLeftText = 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_font(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.font = (TMPro.TMP_FontAsset)translator.GetObject(L, 2, typeof(TMPro.TMP_FontAsset)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_fontSharedMaterial(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.fontSharedMaterial = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_fontSharedMaterials(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.fontSharedMaterials = (UnityEngine.Material[])translator.GetObject(L, 2, typeof(UnityEngine.Material[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_fontMaterial(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.fontMaterial = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_fontMaterials(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.fontMaterials = (UnityEngine.Material[])translator.GetObject(L, 2, typeof(UnityEngine.Material[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_color(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + UnityEngine.Color gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.color = 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_alpha(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.alpha = (float)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_enableVertexGradient(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.enableVertexGradient = 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_colorGradient(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + TMPro.VertexGradient gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.colorGradient = 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_colorGradientPreset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.colorGradientPreset = (TMPro.TMP_ColorGradient)translator.GetObject(L, 2, typeof(TMPro.TMP_ColorGradient)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_spriteAsset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.spriteAsset = (TMPro.TMP_SpriteAsset)translator.GetObject(L, 2, typeof(TMPro.TMP_SpriteAsset)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_tintAllSprites(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.tintAllSprites = 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_styleSheet(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.styleSheet = (TMPro.TMP_StyleSheet)translator.GetObject(L, 2, typeof(TMPro.TMP_StyleSheet)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_textStyle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.textStyle = (TMPro.TMP_Style)translator.GetObject(L, 2, typeof(TMPro.TMP_Style)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_overrideColorTags(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.overrideColorTags = 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_faceColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + UnityEngine.Color32 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.faceColor = 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_outlineColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + UnityEngine.Color32 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.outlineColor = 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_outlineWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.outlineWidth = (float)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_fontSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.fontSize = (float)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_fontWeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + TMPro.FontWeight gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.fontWeight = 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_enableAutoSizing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.enableAutoSizing = 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_fontSizeMin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.fontSizeMin = (float)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_fontSizeMax(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.fontSizeMax = (float)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_fontStyle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + TMPro.FontStyles gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.fontStyle = 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_horizontalAlignment(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + TMPro.HorizontalAlignmentOptions gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.horizontalAlignment = 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_verticalAlignment(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + TMPro.VerticalAlignmentOptions gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.verticalAlignment = 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_alignment(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + TMPro.TextAlignmentOptions gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.alignment = 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_characterSpacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.characterSpacing = (float)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_wordSpacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.wordSpacing = (float)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_lineSpacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.lineSpacing = (float)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_lineSpacingAdjustment(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.lineSpacingAdjustment = (float)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_paragraphSpacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.paragraphSpacing = (float)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_characterWidthAdjustment(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.characterWidthAdjustment = (float)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_enableWordWrapping(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.enableWordWrapping = 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_wordWrappingRatios(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.wordWrappingRatios = (float)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_overflowMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + TMPro.TextOverflowModes gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.overflowMode = 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_linkedTextComponent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.linkedTextComponent = (TMPro.TMP_Text)translator.GetObject(L, 2, typeof(TMPro.TMP_Text)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_enableKerning(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.enableKerning = 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_extraPadding(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.extraPadding = 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_richText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.richText = 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_parseCtrlCharacters(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.parseCtrlCharacters = 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_isOverlay(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.isOverlay = 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_isOrthographic(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.isOrthographic = 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_enableCulling(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.enableCulling = 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_ignoreVisibility(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ignoreVisibility = 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_horizontalMapping(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + TMPro.TextureMappingOptions gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.horizontalMapping = 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_verticalMapping(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + TMPro.TextureMappingOptions gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.verticalMapping = 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_mappingUvLineOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.mappingUvLineOffset = (float)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_renderMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + TMPro.TextRenderFlags gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.renderMode = 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_geometrySortingOrder(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + TMPro.VertexSortingOrder gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.geometrySortingOrder = 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_isTextObjectScaleStatic(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.isTextObjectScaleStatic = 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_vertexBufferAutoSizeReduction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.vertexBufferAutoSizeReduction = 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_firstVisibleCharacter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.firstVisibleCharacter = 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_maxVisibleCharacters(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.maxVisibleCharacters = 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_maxVisibleWords(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.maxVisibleWords = 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_maxVisibleLines(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.maxVisibleLines = 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_useMaxVisibleDescender(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.useMaxVisibleDescender = 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_pageToDisplay(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.pageToDisplay = 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_margin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + UnityEngine.Vector4 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.margin = 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_havePropertiesChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.havePropertiesChanged = 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_isUsingLegacyAnimationComponent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.isUsingLegacyAnimationComponent = 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_autoSizeTextContainer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.autoSizeTextContainer = 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_isVolumetricText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.isVolumetricText = 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 _e_OnPreRenderText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + TMPro.TMP_Text gen_to_be_invoked = (TMPro.TMP_Text)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnPreRenderText += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnPreRenderText -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to TMPro.TMP_Text.OnPreRenderText!"); + return 0; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnFontAssetRequest(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Func gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Func!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + TMPro.TMP_Text.OnFontAssetRequest += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + TMPro.TMP_Text.OnFontAssetRequest -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to TMPro.TMP_Text.OnFontAssetRequest!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnSpriteAssetRequest(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Func gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Func!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + TMPro.TMP_Text.OnSpriteAssetRequest += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + TMPro.TMP_Text.OnSpriteAssetRequest -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to TMPro.TMP_Text.OnSpriteAssetRequest!"); + } + + } +} diff --git a/Assets/XLua/Gen/TMPro_TextMeshProUGUIWrap.cs b/Assets/XLua/Gen/TMPro_TextMeshProUGUIWrap.cs new file mode 100644 index 000000000..50fbfffb3 --- /dev/null +++ b/Assets/XLua/Gen/TMPro_TextMeshProUGUIWrap.cs @@ -0,0 +1,779 @@ +#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 TMProTextMeshProUGUIWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(TMPro.TextMeshProUGUI); + Utils.BeginObjectRegister(type, L, translator, 0, 19, 5, 2); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CalculateLayoutInputHorizontal", _m_CalculateLayoutInputHorizontal); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CalculateLayoutInputVertical", _m_CalculateLayoutInputVertical); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetVerticesDirty", _m_SetVerticesDirty); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLayoutDirty", _m_SetLayoutDirty); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMaterialDirty", _m_SetMaterialDirty); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAllDirty", _m_SetAllDirty); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Rebuild", _m_Rebuild); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetModifiedMaterial", _m_GetModifiedMaterial); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RecalculateClipping", _m_RecalculateClipping); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Cull", _m_Cull); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateMeshPadding", _m_UpdateMeshPadding); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ForceMeshUpdate", _m_ForceMeshUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTextInfo", _m_GetTextInfo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearMesh", _m_ClearMesh); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateGeometry", _m_UpdateGeometry); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateVertexData", _m_UpdateVertexData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateFontAsset", _m_UpdateFontAsset); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ComputeMarginSize", _m_ComputeMarginSize); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPreRenderText", _e_OnPreRenderText); + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "materialForRendering", _g_get_materialForRendering); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "autoSizeTextContainer", _g_get_autoSizeTextContainer); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mesh", _g_get_mesh); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "canvasRenderer", _g_get_canvasRenderer); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "maskOffset", _g_get_maskOffset); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "autoSizeTextContainer", _s_set_autoSizeTextContainer); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "maskOffset", _s_set_maskOffset); + + + 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 TMPro.TextMeshProUGUI(); + 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 TMPro.TextMeshProUGUI constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalculateLayoutInputHorizontal(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshProUGUI gen_to_be_invoked = (TMPro.TextMeshProUGUI)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CalculateLayoutInputHorizontal( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalculateLayoutInputVertical(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshProUGUI gen_to_be_invoked = (TMPro.TextMeshProUGUI)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CalculateLayoutInputVertical( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetVerticesDirty(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshProUGUI gen_to_be_invoked = (TMPro.TextMeshProUGUI)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetVerticesDirty( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLayoutDirty(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshProUGUI gen_to_be_invoked = (TMPro.TextMeshProUGUI)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetLayoutDirty( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMaterialDirty(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshProUGUI gen_to_be_invoked = (TMPro.TextMeshProUGUI)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetMaterialDirty( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAllDirty(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshProUGUI gen_to_be_invoked = (TMPro.TextMeshProUGUI)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetAllDirty( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Rebuild(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshProUGUI gen_to_be_invoked = (TMPro.TextMeshProUGUI)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.UI.CanvasUpdate _update;translator.Get(L, 2, out _update); + + gen_to_be_invoked.Rebuild( _update ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetModifiedMaterial(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshProUGUI gen_to_be_invoked = (TMPro.TextMeshProUGUI)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Material _baseMaterial = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + var gen_ret = gen_to_be_invoked.GetModifiedMaterial( _baseMaterial ); + 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_RecalculateClipping(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshProUGUI gen_to_be_invoked = (TMPro.TextMeshProUGUI)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RecalculateClipping( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Cull(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshProUGUI gen_to_be_invoked = (TMPro.TextMeshProUGUI)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Rect _clipRect;translator.Get(L, 2, out _clipRect); + bool _validRect = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.Cull( _clipRect, _validRect ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UpdateMeshPadding(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshProUGUI gen_to_be_invoked = (TMPro.TextMeshProUGUI)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.UpdateMeshPadding( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ForceMeshUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshProUGUI gen_to_be_invoked = (TMPro.TextMeshProUGUI)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + bool _ignoreActiveState = LuaAPI.lua_toboolean(L, 2); + bool _forceTextReparsing = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.ForceMeshUpdate( _ignoreActiveState, _forceTextReparsing ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _ignoreActiveState = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.ForceMeshUpdate( _ignoreActiveState ); + + + + return 0; + } + if(gen_param_count == 1) + { + + gen_to_be_invoked.ForceMeshUpdate( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to TMPro.TextMeshProUGUI.ForceMeshUpdate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetTextInfo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshProUGUI gen_to_be_invoked = (TMPro.TextMeshProUGUI)translator.FastGetCSObj(L, 1); + + + + { + string _text = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetTextInfo( _text ); + 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_ClearMesh(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshProUGUI gen_to_be_invoked = (TMPro.TextMeshProUGUI)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearMesh( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UpdateGeometry(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshProUGUI gen_to_be_invoked = (TMPro.TextMeshProUGUI)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + int _index = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.UpdateGeometry( _mesh, _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UpdateVertexData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshProUGUI gen_to_be_invoked = (TMPro.TextMeshProUGUI)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.UpdateVertexData( ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + TMPro.TMP_VertexDataUpdateFlags _flags;translator.Get(L, 2, out _flags); + + gen_to_be_invoked.UpdateVertexData( _flags ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to TMPro.TextMeshProUGUI.UpdateVertexData!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UpdateFontAsset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshProUGUI gen_to_be_invoked = (TMPro.TextMeshProUGUI)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.UpdateFontAsset( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ComputeMarginSize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshProUGUI gen_to_be_invoked = (TMPro.TextMeshProUGUI)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ComputeMarginSize( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_materialForRendering(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TextMeshProUGUI gen_to_be_invoked = (TMPro.TextMeshProUGUI)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.materialForRendering); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_autoSizeTextContainer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TextMeshProUGUI gen_to_be_invoked = (TMPro.TextMeshProUGUI)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.autoSizeTextContainer); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mesh(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TextMeshProUGUI gen_to_be_invoked = (TMPro.TextMeshProUGUI)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.mesh); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_canvasRenderer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TextMeshProUGUI gen_to_be_invoked = (TMPro.TextMeshProUGUI)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.canvasRenderer); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maskOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TextMeshProUGUI gen_to_be_invoked = (TMPro.TextMeshProUGUI)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector4(L, gen_to_be_invoked.maskOffset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_autoSizeTextContainer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TextMeshProUGUI gen_to_be_invoked = (TMPro.TextMeshProUGUI)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.autoSizeTextContainer = 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_maskOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TextMeshProUGUI gen_to_be_invoked = (TMPro.TextMeshProUGUI)translator.FastGetCSObj(L, 1); + UnityEngine.Vector4 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.maskOffset = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnPreRenderText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + TMPro.TextMeshProUGUI gen_to_be_invoked = (TMPro.TextMeshProUGUI)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnPreRenderText += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnPreRenderText -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to TMPro.TextMeshProUGUI.OnPreRenderText!"); + return 0; + } + + + + } +} diff --git a/Assets/XLua/Gen/TMPro_TextMeshProWrap.cs b/Assets/XLua/Gen/TMPro_TextMeshProWrap.cs new file mode 100644 index 000000000..b91da5062 --- /dev/null +++ b/Assets/XLua/Gen/TMPro_TextMeshProWrap.cs @@ -0,0 +1,816 @@ +#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 TMProTextMeshProWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(TMPro.TextMeshPro); + Utils.BeginObjectRegister(type, L, translator, 0, 17, 8, 4); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMask", _m_SetMask); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetVerticesDirty", _m_SetVerticesDirty); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLayoutDirty", _m_SetLayoutDirty); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMaterialDirty", _m_SetMaterialDirty); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAllDirty", _m_SetAllDirty); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Rebuild", _m_Rebuild); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateMeshPadding", _m_UpdateMeshPadding); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ForceMeshUpdate", _m_ForceMeshUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTextInfo", _m_GetTextInfo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearMesh", _m_ClearMesh); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateGeometry", _m_UpdateGeometry); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateVertexData", _m_UpdateVertexData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateFontAsset", _m_UpdateFontAsset); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CalculateLayoutInputHorizontal", _m_CalculateLayoutInputHorizontal); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CalculateLayoutInputVertical", _m_CalculateLayoutInputVertical); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ComputeMarginSize", _m_ComputeMarginSize); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPreRenderText", _e_OnPreRenderText); + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sortingLayerID", _g_get_sortingLayerID); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sortingOrder", _g_get_sortingOrder); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "autoSizeTextContainer", _g_get_autoSizeTextContainer); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "transform", _g_get_transform); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "renderer", _g_get_renderer); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mesh", _g_get_mesh); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "meshFilter", _g_get_meshFilter); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "maskType", _g_get_maskType); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sortingLayerID", _s_set_sortingLayerID); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sortingOrder", _s_set_sortingOrder); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "autoSizeTextContainer", _s_set_autoSizeTextContainer); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "maskType", _s_set_maskType); + + + 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 TMPro.TextMeshPro(); + 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 TMPro.TextMeshPro constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMask(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshPro gen_to_be_invoked = (TMPro.TextMeshPro)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + TMPro.MaskingTypes _type;translator.Get(L, 2, out _type); + UnityEngine.Vector4 _maskCoords;translator.Get(L, 3, out _maskCoords); + + gen_to_be_invoked.SetMask( _type, _maskCoords ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + TMPro.MaskingTypes _type;translator.Get(L, 2, out _type); + UnityEngine.Vector4 _maskCoords;translator.Get(L, 3, out _maskCoords); + float _softnessX = (float)LuaAPI.lua_tonumber(L, 4); + float _softnessY = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.SetMask( _type, _maskCoords, _softnessX, _softnessY ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to TMPro.TextMeshPro.SetMask!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetVerticesDirty(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshPro gen_to_be_invoked = (TMPro.TextMeshPro)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetVerticesDirty( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLayoutDirty(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshPro gen_to_be_invoked = (TMPro.TextMeshPro)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetLayoutDirty( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMaterialDirty(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshPro gen_to_be_invoked = (TMPro.TextMeshPro)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetMaterialDirty( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAllDirty(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshPro gen_to_be_invoked = (TMPro.TextMeshPro)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetAllDirty( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Rebuild(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshPro gen_to_be_invoked = (TMPro.TextMeshPro)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.UI.CanvasUpdate _update;translator.Get(L, 2, out _update); + + gen_to_be_invoked.Rebuild( _update ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UpdateMeshPadding(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshPro gen_to_be_invoked = (TMPro.TextMeshPro)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.UpdateMeshPadding( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ForceMeshUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshPro gen_to_be_invoked = (TMPro.TextMeshPro)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + bool _ignoreActiveState = LuaAPI.lua_toboolean(L, 2); + bool _forceTextReparsing = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.ForceMeshUpdate( _ignoreActiveState, _forceTextReparsing ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _ignoreActiveState = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.ForceMeshUpdate( _ignoreActiveState ); + + + + return 0; + } + if(gen_param_count == 1) + { + + gen_to_be_invoked.ForceMeshUpdate( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to TMPro.TextMeshPro.ForceMeshUpdate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetTextInfo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshPro gen_to_be_invoked = (TMPro.TextMeshPro)translator.FastGetCSObj(L, 1); + + + + { + string _text = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetTextInfo( _text ); + 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_ClearMesh(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshPro gen_to_be_invoked = (TMPro.TextMeshPro)translator.FastGetCSObj(L, 1); + + + + { + bool _updateMesh = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.ClearMesh( _updateMesh ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UpdateGeometry(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshPro gen_to_be_invoked = (TMPro.TextMeshPro)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + int _index = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.UpdateGeometry( _mesh, _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UpdateVertexData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshPro gen_to_be_invoked = (TMPro.TextMeshPro)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.UpdateVertexData( ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + TMPro.TMP_VertexDataUpdateFlags _flags;translator.Get(L, 2, out _flags); + + gen_to_be_invoked.UpdateVertexData( _flags ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to TMPro.TextMeshPro.UpdateVertexData!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UpdateFontAsset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshPro gen_to_be_invoked = (TMPro.TextMeshPro)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.UpdateFontAsset( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalculateLayoutInputHorizontal(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshPro gen_to_be_invoked = (TMPro.TextMeshPro)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CalculateLayoutInputHorizontal( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalculateLayoutInputVertical(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshPro gen_to_be_invoked = (TMPro.TextMeshPro)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CalculateLayoutInputVertical( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ComputeMarginSize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + TMPro.TextMeshPro gen_to_be_invoked = (TMPro.TextMeshPro)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ComputeMarginSize( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sortingLayerID(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TextMeshPro gen_to_be_invoked = (TMPro.TextMeshPro)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.sortingLayerID); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sortingOrder(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TextMeshPro gen_to_be_invoked = (TMPro.TextMeshPro)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.sortingOrder); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_autoSizeTextContainer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TextMeshPro gen_to_be_invoked = (TMPro.TextMeshPro)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.autoSizeTextContainer); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_transform(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TextMeshPro gen_to_be_invoked = (TMPro.TextMeshPro)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.transform); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_renderer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TextMeshPro gen_to_be_invoked = (TMPro.TextMeshPro)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.renderer); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mesh(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TextMeshPro gen_to_be_invoked = (TMPro.TextMeshPro)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.mesh); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_meshFilter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TextMeshPro gen_to_be_invoked = (TMPro.TextMeshPro)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.meshFilter); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maskType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TextMeshPro gen_to_be_invoked = (TMPro.TextMeshPro)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.maskType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_sortingLayerID(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TextMeshPro gen_to_be_invoked = (TMPro.TextMeshPro)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.sortingLayerID = 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_sortingOrder(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TextMeshPro gen_to_be_invoked = (TMPro.TextMeshPro)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.sortingOrder = 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_autoSizeTextContainer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TextMeshPro gen_to_be_invoked = (TMPro.TextMeshPro)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.autoSizeTextContainer = 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_maskType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + TMPro.TextMeshPro gen_to_be_invoked = (TMPro.TextMeshPro)translator.FastGetCSObj(L, 1); + TMPro.MaskingTypes gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.maskType = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_OnPreRenderText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + TMPro.TextMeshPro gen_to_be_invoked = (TMPro.TextMeshPro)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.OnPreRenderText += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.OnPreRenderText -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to TMPro.TextMeshPro.OnPreRenderText!"); + return 0; + } + + + + } +} diff --git a/Assets/XLua/Gen/ThinkingAnalytics_TDFirstEventWrap.cs b/Assets/XLua/Gen/ThinkingAnalytics_TDFirstEventWrap.cs new file mode 100644 index 000000000..44ed2915b --- /dev/null +++ b/Assets/XLua/Gen/ThinkingAnalytics_TDFirstEventWrap.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 ThinkingAnalyticsTDFirstEventWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(ThinkingAnalytics.TDFirstEvent); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetFirstCheckId", _m_SetFirstCheckId); + + + + + + 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) && translator.Assignable>(L, 3)) + { + string _eventName = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 3, typeof(System.Collections.Generic.Dictionary)); + + var gen_ret = new ThinkingAnalytics.TDFirstEvent(_eventName, _properties); + 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 ThinkingAnalytics.TDFirstEvent constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetFirstCheckId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.TDFirstEvent gen_to_be_invoked = (ThinkingAnalytics.TDFirstEvent)translator.FastGetCSObj(L, 1); + + + + { + string _firstCheckId = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SetFirstCheckId( _firstCheckId ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/ThinkingAnalytics_TDOverWritableEventWrap.cs b/Assets/XLua/Gen/ThinkingAnalytics_TDOverWritableEventWrap.cs new file mode 100644 index 000000000..b0d0f9d9a --- /dev/null +++ b/Assets/XLua/Gen/ThinkingAnalytics_TDOverWritableEventWrap.cs @@ -0,0 +1,87 @@ +#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 ThinkingAnalyticsTDOverWritableEventWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(ThinkingAnalytics.TDOverWritableEvent); + 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) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 4 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING) && translator.Assignable>(L, 3) && (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)) + { + string _eventName = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 3, typeof(System.Collections.Generic.Dictionary)); + string _eventId = LuaAPI.lua_tostring(L, 4); + + var gen_ret = new ThinkingAnalytics.TDOverWritableEvent(_eventName, _properties, _eventId); + 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 ThinkingAnalytics.TDOverWritableEvent constructor!"); + + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/ThinkingAnalytics_TDPresetPropertiesWrap.cs b/Assets/XLua/Gen/ThinkingAnalytics_TDPresetPropertiesWrap.cs new file mode 100644 index 000000000..5f2b47274 --- /dev/null +++ b/Assets/XLua/Gen/ThinkingAnalytics_TDPresetPropertiesWrap.cs @@ -0,0 +1,294 @@ +#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 ThinkingAnalyticsTDPresetPropertiesWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(ThinkingAnalytics.TDPresetProperties); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 12, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToEventPresetProperties", _m_ToEventPresetProperties); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "BundleId", _g_get_BundleId); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Carrier", _g_get_Carrier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "DeviceId", _g_get_DeviceId); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "DeviceModel", _g_get_DeviceModel); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Manufacturer", _g_get_Manufacturer); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "NetworkType", _g_get_NetworkType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "OS", _g_get_OS); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "OSVersion", _g_get_OSVersion); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ScreenHeight", _g_get_ScreenHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ScreenWidth", _g_get_ScreenWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "SystemLanguage", _g_get_SystemLanguage); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ZoneOffset", _g_get_ZoneOffset); + + + + 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) == 2 && translator.Assignable>(L, 2)) + { + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + + var gen_ret = new ThinkingAnalytics.TDPresetProperties(_properties); + 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 ThinkingAnalytics.TDPresetProperties constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToEventPresetProperties(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.TDPresetProperties gen_to_be_invoked = (ThinkingAnalytics.TDPresetProperties)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.ToEventPresetProperties( ); + 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_BundleId(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.TDPresetProperties gen_to_be_invoked = (ThinkingAnalytics.TDPresetProperties)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.BundleId); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Carrier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.TDPresetProperties gen_to_be_invoked = (ThinkingAnalytics.TDPresetProperties)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Carrier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DeviceId(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.TDPresetProperties gen_to_be_invoked = (ThinkingAnalytics.TDPresetProperties)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.DeviceId); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DeviceModel(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.TDPresetProperties gen_to_be_invoked = (ThinkingAnalytics.TDPresetProperties)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.DeviceModel); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Manufacturer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.TDPresetProperties gen_to_be_invoked = (ThinkingAnalytics.TDPresetProperties)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Manufacturer); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_NetworkType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.TDPresetProperties gen_to_be_invoked = (ThinkingAnalytics.TDPresetProperties)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.NetworkType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_OS(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.TDPresetProperties gen_to_be_invoked = (ThinkingAnalytics.TDPresetProperties)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.OS); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_OSVersion(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.TDPresetProperties gen_to_be_invoked = (ThinkingAnalytics.TDPresetProperties)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.OSVersion); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ScreenHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.TDPresetProperties gen_to_be_invoked = (ThinkingAnalytics.TDPresetProperties)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushint64(L, gen_to_be_invoked.ScreenHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ScreenWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.TDPresetProperties gen_to_be_invoked = (ThinkingAnalytics.TDPresetProperties)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushint64(L, gen_to_be_invoked.ScreenWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_SystemLanguage(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.TDPresetProperties gen_to_be_invoked = (ThinkingAnalytics.TDPresetProperties)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.SystemLanguage); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ZoneOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.TDPresetProperties gen_to_be_invoked = (ThinkingAnalytics.TDPresetProperties)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.ZoneOffset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/ThinkingAnalytics_TDUpdatableEventWrap.cs b/Assets/XLua/Gen/ThinkingAnalytics_TDUpdatableEventWrap.cs new file mode 100644 index 000000000..52683c0dc --- /dev/null +++ b/Assets/XLua/Gen/ThinkingAnalytics_TDUpdatableEventWrap.cs @@ -0,0 +1,87 @@ +#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 ThinkingAnalyticsTDUpdatableEventWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(ThinkingAnalytics.TDUpdatableEvent); + 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) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 4 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING) && translator.Assignable>(L, 3) && (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)) + { + string _eventName = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 3, typeof(System.Collections.Generic.Dictionary)); + string _eventId = LuaAPI.lua_tostring(L, 4); + + var gen_ret = new ThinkingAnalytics.TDUpdatableEvent(_eventName, _properties, _eventId); + 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 ThinkingAnalytics.TDUpdatableEvent constructor!"); + + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/ThinkingAnalytics_TaException_ThinkingSDKExceptionHandlerWrap.cs b/Assets/XLua/Gen/ThinkingAnalytics_TaException_ThinkingSDKExceptionHandlerWrap.cs new file mode 100644 index 000000000..40c4649e0 --- /dev/null +++ b/Assets/XLua/Gen/ThinkingAnalytics_TaException_ThinkingSDKExceptionHandlerWrap.cs @@ -0,0 +1,200 @@ +#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 ThinkingAnalyticsTaExceptionThinkingSDKExceptionHandlerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(ThinkingAnalytics.TaException.ThinkingSDKExceptionHandler); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 1, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTaExceptionHandler", _m_SetTaExceptionHandler); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RegisterTaExceptionHandler", _m_RegisterTaExceptionHandler); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnregisterTaExceptionHandler", _m_UnregisterTaExceptionHandler); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsQuitWhenException", _g_get_IsQuitWhenException); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "IsQuitWhenException", _s_set_IsQuitWhenException); + + + 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 ThinkingAnalytics.TaException.ThinkingSDKExceptionHandler(); + 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 ThinkingAnalytics.TaException.ThinkingSDKExceptionHandler constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTaExceptionHandler(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.TaException.ThinkingSDKExceptionHandler gen_to_be_invoked = (ThinkingAnalytics.TaException.ThinkingSDKExceptionHandler)translator.FastGetCSObj(L, 1); + + + + { + ThinkingAnalytics.TaException.TaExceptionHandler _handler = (ThinkingAnalytics.TaException.TaExceptionHandler)translator.GetObject(L, 2, typeof(ThinkingAnalytics.TaException.TaExceptionHandler)); + + gen_to_be_invoked.SetTaExceptionHandler( _handler ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RegisterTaExceptionHandler(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.TaException.ThinkingSDKExceptionHandler gen_to_be_invoked = (ThinkingAnalytics.TaException.ThinkingSDKExceptionHandler)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RegisterTaExceptionHandler( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UnregisterTaExceptionHandler(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.TaException.ThinkingSDKExceptionHandler gen_to_be_invoked = (ThinkingAnalytics.TaException.ThinkingSDKExceptionHandler)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.UnregisterTaExceptionHandler( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_IsQuitWhenException(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.TaException.ThinkingSDKExceptionHandler gen_to_be_invoked = (ThinkingAnalytics.TaException.ThinkingSDKExceptionHandler)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.IsQuitWhenException); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_IsQuitWhenException(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.TaException.ThinkingSDKExceptionHandler gen_to_be_invoked = (ThinkingAnalytics.TaException.ThinkingSDKExceptionHandler)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.IsQuitWhenException = LuaAPI.lua_toboolean(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/ThinkingAnalytics_ThinkingAnalyticsAPIWrap.cs b/Assets/XLua/Gen/ThinkingAnalytics_ThinkingAnalyticsAPIWrap.cs new file mode 100644 index 000000000..f77872be6 --- /dev/null +++ b/Assets/XLua/Gen/ThinkingAnalytics_ThinkingAnalyticsAPIWrap.cs @@ -0,0 +1,1751 @@ +#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 ThinkingAnalyticsThinkingAnalyticsAPIWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(ThinkingAnalytics.ThinkingAnalyticsAPI); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 5, 4); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InvokeTaExceptionHandler", _m_InvokeTaExceptionHandler); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startManually", _g_get_startManually); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enableLog", _g_get_enableLog); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "networkType", _g_get_networkType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "tokens", _g_get_tokens); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "VERSION", _g_get_VERSION); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startManually", _s_set_startManually); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enableLog", _s_set_enableLog); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "networkType", _s_set_networkType); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "tokens", _s_set_tokens); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 33, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Identify", _m_Identify_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetDistinctId", _m_GetDistinctId_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Login", _m_Login_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Logout", _m_Logout_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Flush", _m_Flush_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "EnableAutoTrack", _m_EnableAutoTrack_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetAutoTrackProperties", _m_SetAutoTrackProperties_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Track", _m_Track_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetSuperProperties", _m_SetSuperProperties_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "UnsetSuperProperty", _m_UnsetSuperProperty_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetSuperProperties", _m_GetSuperProperties_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ClearSuperProperties", _m_ClearSuperProperties_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetPresetProperties", _m_GetPresetProperties_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "TimeEvent", _m_TimeEvent_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "UserSet", _m_UserSet_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "UserUnset", _m_UserUnset_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "UserSetOnce", _m_UserSetOnce_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "UserAdd", _m_UserAdd_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "UserAppend", _m_UserAppend_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "UserDelete", _m_UserDelete_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetNetworkType", _m_SetNetworkType_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetDeviceId", _m_GetDeviceId_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetDynamicSuperProperties", _m_SetDynamicSuperProperties_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "OptOutTracking", _m_OptOutTracking_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "OptOutTrackingAndDeleteUser", _m_OptOutTrackingAndDeleteUser_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "OptInTracking", _m_OptInTracking_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "EnableTracking", _m_EnableTracking_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CreateLightInstance", _m_CreateLightInstance_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CalibrateTime", _m_CalibrateTime_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CalibrateTimeWithNtp", _m_CalibrateTimeWithNtp_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "setDefaultAppid", _m_setDefaultAppid_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "StartThinkingAnalytics", _m_StartThinkingAnalytics_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 ThinkingAnalytics.ThinkingAnalyticsAPI(); + 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 ThinkingAnalytics.ThinkingAnalyticsAPI constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Identify_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _FIRSTId = LuaAPI.lua_tostring(L, 1); + string _appId = LuaAPI.lua_tostring(L, 2); + + ThinkingAnalytics.ThinkingAnalyticsAPI.Identify( _FIRSTId, _appId ); + + + + return 0; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _FIRSTId = LuaAPI.lua_tostring(L, 1); + + ThinkingAnalytics.ThinkingAnalyticsAPI.Identify( _FIRSTId ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.ThinkingAnalyticsAPI.Identify!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetDistinctId_xlua_st_(RealStatePtr L) + { + try { + + + + 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 _appId = LuaAPI.lua_tostring(L, 1); + + var gen_ret = ThinkingAnalytics.ThinkingAnalyticsAPI.GetDistinctId( _appId ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 0) + { + + var gen_ret = ThinkingAnalytics.ThinkingAnalyticsAPI.GetDistinctId( ); + LuaAPI.lua_pushstring(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 ThinkingAnalytics.ThinkingAnalyticsAPI.GetDistinctId!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Login_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _account = LuaAPI.lua_tostring(L, 1); + string _appId = LuaAPI.lua_tostring(L, 2); + + ThinkingAnalytics.ThinkingAnalyticsAPI.Login( _account, _appId ); + + + + return 0; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _account = LuaAPI.lua_tostring(L, 1); + + ThinkingAnalytics.ThinkingAnalyticsAPI.Login( _account ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.ThinkingAnalyticsAPI.Login!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Logout_xlua_st_(RealStatePtr L) + { + try { + + + + 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 _appId = LuaAPI.lua_tostring(L, 1); + + ThinkingAnalytics.ThinkingAnalyticsAPI.Logout( _appId ); + + + + return 0; + } + if(gen_param_count == 0) + { + + ThinkingAnalytics.ThinkingAnalyticsAPI.Logout( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.ThinkingAnalyticsAPI.Logout!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Flush_xlua_st_(RealStatePtr L) + { + try { + + + + 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 _appId = LuaAPI.lua_tostring(L, 1); + + ThinkingAnalytics.ThinkingAnalyticsAPI.Flush( _appId ); + + + + return 0; + } + if(gen_param_count == 0) + { + + ThinkingAnalytics.ThinkingAnalyticsAPI.Flush( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.ThinkingAnalyticsAPI.Flush!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_EnableAutoTrack_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable>(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + ThinkingAnalytics.AUTO_TRACK_EVENTS _events;translator.Get(L, 1, out _events); + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + string _appId = LuaAPI.lua_tostring(L, 3); + + ThinkingAnalytics.ThinkingAnalyticsAPI.EnableAutoTrack( _events, _properties, _appId ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable>(L, 2)) + { + ThinkingAnalytics.AUTO_TRACK_EVENTS _events;translator.Get(L, 1, out _events); + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + + ThinkingAnalytics.ThinkingAnalyticsAPI.EnableAutoTrack( _events, _properties ); + + + + return 0; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + ThinkingAnalytics.AUTO_TRACK_EVENTS _events;translator.Get(L, 1, out _events); + + ThinkingAnalytics.ThinkingAnalyticsAPI.EnableAutoTrack( _events ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.ThinkingAnalyticsAPI.EnableAutoTrack!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAutoTrackProperties_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable>(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + ThinkingAnalytics.AUTO_TRACK_EVENTS _events;translator.Get(L, 1, out _events); + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + string _appId = LuaAPI.lua_tostring(L, 3); + + ThinkingAnalytics.ThinkingAnalyticsAPI.SetAutoTrackProperties( _events, _properties, _appId ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable>(L, 2)) + { + ThinkingAnalytics.AUTO_TRACK_EVENTS _events;translator.Get(L, 1, out _events); + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + + ThinkingAnalytics.ThinkingAnalyticsAPI.SetAutoTrackProperties( _events, _properties ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.ThinkingAnalyticsAPI.SetAutoTrackProperties!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_InvokeTaExceptionHandler(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.ThinkingAnalyticsAPI gen_to_be_invoked = (ThinkingAnalytics.ThinkingAnalyticsAPI)translator.FastGetCSObj(L, 1); + + + + { + string _eventName = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 3, typeof(System.Collections.Generic.Dictionary)); + + gen_to_be_invoked.InvokeTaExceptionHandler( _eventName, _properties ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Track_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _eventName = LuaAPI.lua_tostring(L, 1); + string _appId = LuaAPI.lua_tostring(L, 2); + + ThinkingAnalytics.ThinkingAnalyticsAPI.Track( _eventName, _appId ); + + + + return 0; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _eventName = LuaAPI.lua_tostring(L, 1); + + ThinkingAnalytics.ThinkingAnalyticsAPI.Track( _eventName ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + ThinkingAnalytics.ThinkingAnalyticsEvent _analyticsEvent = (ThinkingAnalytics.ThinkingAnalyticsEvent)translator.GetObject(L, 1, typeof(ThinkingAnalytics.ThinkingAnalyticsEvent)); + string _appId = LuaAPI.lua_tostring(L, 2); + + ThinkingAnalytics.ThinkingAnalyticsAPI.Track( _analyticsEvent, _appId ); + + + + return 0; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + ThinkingAnalytics.ThinkingAnalyticsEvent _analyticsEvent = (ThinkingAnalytics.ThinkingAnalyticsEvent)translator.GetObject(L, 1, typeof(ThinkingAnalytics.ThinkingAnalyticsEvent)); + + ThinkingAnalytics.ThinkingAnalyticsAPI.Track( _analyticsEvent ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + string _eventName = LuaAPI.lua_tostring(L, 1); + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + string _appId = LuaAPI.lua_tostring(L, 3); + + ThinkingAnalytics.ThinkingAnalyticsAPI.Track( _eventName, _properties, _appId ); + + + + 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 _eventName = LuaAPI.lua_tostring(L, 1); + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + + ThinkingAnalytics.ThinkingAnalyticsAPI.Track( _eventName, _properties ); + + + + return 0; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)) + { + string _eventName = LuaAPI.lua_tostring(L, 1); + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + System.DateTime _date;translator.Get(L, 3, out _date); + string _appId = LuaAPI.lua_tostring(L, 4); + + ThinkingAnalytics.ThinkingAnalyticsAPI.Track( _eventName, _properties, _date, _appId ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)) + { + string _eventName = LuaAPI.lua_tostring(L, 1); + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + System.DateTime _date;translator.Get(L, 3, out _date); + + ThinkingAnalytics.ThinkingAnalyticsAPI.Track( _eventName, _properties, _date ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.ThinkingAnalyticsAPI.Track!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSuperProperties_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + System.Collections.Generic.Dictionary _superProperties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary)); + string _appId = LuaAPI.lua_tostring(L, 2); + + ThinkingAnalytics.ThinkingAnalyticsAPI.SetSuperProperties( _superProperties, _appId ); + + + + return 0; + } + if(gen_param_count == 1&& translator.Assignable>(L, 1)) + { + System.Collections.Generic.Dictionary _superProperties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary)); + + ThinkingAnalytics.ThinkingAnalyticsAPI.SetSuperProperties( _superProperties ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.ThinkingAnalyticsAPI.SetSuperProperties!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UnsetSuperProperty_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _property = LuaAPI.lua_tostring(L, 1); + string _appId = LuaAPI.lua_tostring(L, 2); + + ThinkingAnalytics.ThinkingAnalyticsAPI.UnsetSuperProperty( _property, _appId ); + + + + return 0; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _property = LuaAPI.lua_tostring(L, 1); + + ThinkingAnalytics.ThinkingAnalyticsAPI.UnsetSuperProperty( _property ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.ThinkingAnalyticsAPI.UnsetSuperProperty!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetSuperProperties_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 _appId = LuaAPI.lua_tostring(L, 1); + + var gen_ret = ThinkingAnalytics.ThinkingAnalyticsAPI.GetSuperProperties( _appId ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 0) + { + + var gen_ret = ThinkingAnalytics.ThinkingAnalyticsAPI.GetSuperProperties( ); + 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 ThinkingAnalytics.ThinkingAnalyticsAPI.GetSuperProperties!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearSuperProperties_xlua_st_(RealStatePtr L) + { + try { + + + + 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 _appId = LuaAPI.lua_tostring(L, 1); + + ThinkingAnalytics.ThinkingAnalyticsAPI.ClearSuperProperties( _appId ); + + + + return 0; + } + if(gen_param_count == 0) + { + + ThinkingAnalytics.ThinkingAnalyticsAPI.ClearSuperProperties( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.ThinkingAnalyticsAPI.ClearSuperProperties!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetPresetProperties_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 _appId = LuaAPI.lua_tostring(L, 1); + + var gen_ret = ThinkingAnalytics.ThinkingAnalyticsAPI.GetPresetProperties( _appId ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 0) + { + + var gen_ret = ThinkingAnalytics.ThinkingAnalyticsAPI.GetPresetProperties( ); + 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 ThinkingAnalytics.ThinkingAnalyticsAPI.GetPresetProperties!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TimeEvent_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _eventName = LuaAPI.lua_tostring(L, 1); + string _appId = LuaAPI.lua_tostring(L, 2); + + ThinkingAnalytics.ThinkingAnalyticsAPI.TimeEvent( _eventName, _appId ); + + + + return 0; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _eventName = LuaAPI.lua_tostring(L, 1); + + ThinkingAnalytics.ThinkingAnalyticsAPI.TimeEvent( _eventName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.ThinkingAnalyticsAPI.TimeEvent!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UserSet_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary)); + string _appId = LuaAPI.lua_tostring(L, 2); + + ThinkingAnalytics.ThinkingAnalyticsAPI.UserSet( _properties, _appId ); + + + + return 0; + } + if(gen_param_count == 1&& translator.Assignable>(L, 1)) + { + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary)); + + ThinkingAnalytics.ThinkingAnalyticsAPI.UserSet( _properties ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable>(L, 1)&& translator.Assignable(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary)); + System.DateTime _dateTime;translator.Get(L, 2, out _dateTime); + string _appId = LuaAPI.lua_tostring(L, 3); + + ThinkingAnalytics.ThinkingAnalyticsAPI.UserSet( _properties, _dateTime, _appId ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 1)&& translator.Assignable(L, 2)) + { + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary)); + System.DateTime _dateTime;translator.Get(L, 2, out _dateTime); + + ThinkingAnalytics.ThinkingAnalyticsAPI.UserSet( _properties, _dateTime ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.ThinkingAnalyticsAPI.UserSet!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UserUnset_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _property = LuaAPI.lua_tostring(L, 1); + string _appId = LuaAPI.lua_tostring(L, 2); + + ThinkingAnalytics.ThinkingAnalyticsAPI.UserUnset( _property, _appId ); + + + + return 0; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _property = LuaAPI.lua_tostring(L, 1); + + ThinkingAnalytics.ThinkingAnalyticsAPI.UserUnset( _property ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + System.Collections.Generic.List _properties = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + string _appId = LuaAPI.lua_tostring(L, 2); + + ThinkingAnalytics.ThinkingAnalyticsAPI.UserUnset( _properties, _appId ); + + + + return 0; + } + if(gen_param_count == 1&& translator.Assignable>(L, 1)) + { + System.Collections.Generic.List _properties = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + + ThinkingAnalytics.ThinkingAnalyticsAPI.UserUnset( _properties ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable>(L, 1)&& translator.Assignable(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + System.Collections.Generic.List _properties = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + System.DateTime _dateTime;translator.Get(L, 2, out _dateTime); + string _appId = LuaAPI.lua_tostring(L, 3); + + ThinkingAnalytics.ThinkingAnalyticsAPI.UserUnset( _properties, _dateTime, _appId ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 1)&& translator.Assignable(L, 2)) + { + System.Collections.Generic.List _properties = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + System.DateTime _dateTime;translator.Get(L, 2, out _dateTime); + + ThinkingAnalytics.ThinkingAnalyticsAPI.UserUnset( _properties, _dateTime ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.ThinkingAnalyticsAPI.UserUnset!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UserSetOnce_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary)); + string _appId = LuaAPI.lua_tostring(L, 2); + + ThinkingAnalytics.ThinkingAnalyticsAPI.UserSetOnce( _properties, _appId ); + + + + return 0; + } + if(gen_param_count == 1&& translator.Assignable>(L, 1)) + { + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary)); + + ThinkingAnalytics.ThinkingAnalyticsAPI.UserSetOnce( _properties ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable>(L, 1)&& translator.Assignable(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary)); + System.DateTime _dateTime;translator.Get(L, 2, out _dateTime); + string _appId = LuaAPI.lua_tostring(L, 3); + + ThinkingAnalytics.ThinkingAnalyticsAPI.UserSetOnce( _properties, _dateTime, _appId ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 1)&& translator.Assignable(L, 2)) + { + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary)); + System.DateTime _dateTime;translator.Get(L, 2, out _dateTime); + + ThinkingAnalytics.ThinkingAnalyticsAPI.UserSetOnce( _properties, _dateTime ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.ThinkingAnalyticsAPI.UserSetOnce!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UserAdd_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary)); + string _appId = LuaAPI.lua_tostring(L, 2); + + ThinkingAnalytics.ThinkingAnalyticsAPI.UserAdd( _properties, _appId ); + + + + return 0; + } + if(gen_param_count == 1&& translator.Assignable>(L, 1)) + { + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary)); + + ThinkingAnalytics.ThinkingAnalyticsAPI.UserAdd( _properties ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + string _property = LuaAPI.lua_tostring(L, 1); + object _value = translator.GetObject(L, 2, typeof(object)); + string _appId = LuaAPI.lua_tostring(L, 3); + + ThinkingAnalytics.ThinkingAnalyticsAPI.UserAdd( _property, _value, _appId ); + + + + 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 _property = LuaAPI.lua_tostring(L, 1); + object _value = translator.GetObject(L, 2, typeof(object)); + + ThinkingAnalytics.ThinkingAnalyticsAPI.UserAdd( _property, _value ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable>(L, 1)&& translator.Assignable(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary)); + System.DateTime _dateTime;translator.Get(L, 2, out _dateTime); + string _appId = LuaAPI.lua_tostring(L, 3); + + ThinkingAnalytics.ThinkingAnalyticsAPI.UserAdd( _properties, _dateTime, _appId ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 1)&& translator.Assignable(L, 2)) + { + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary)); + System.DateTime _dateTime;translator.Get(L, 2, out _dateTime); + + ThinkingAnalytics.ThinkingAnalyticsAPI.UserAdd( _properties, _dateTime ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.ThinkingAnalyticsAPI.UserAdd!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UserAppend_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary)); + string _appId = LuaAPI.lua_tostring(L, 2); + + ThinkingAnalytics.ThinkingAnalyticsAPI.UserAppend( _properties, _appId ); + + + + return 0; + } + if(gen_param_count == 1&& translator.Assignable>(L, 1)) + { + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary)); + + ThinkingAnalytics.ThinkingAnalyticsAPI.UserAppend( _properties ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable>(L, 1)&& translator.Assignable(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary)); + System.DateTime _dateTime;translator.Get(L, 2, out _dateTime); + string _appId = LuaAPI.lua_tostring(L, 3); + + ThinkingAnalytics.ThinkingAnalyticsAPI.UserAppend( _properties, _dateTime, _appId ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 1)&& translator.Assignable(L, 2)) + { + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary)); + System.DateTime _dateTime;translator.Get(L, 2, out _dateTime); + + ThinkingAnalytics.ThinkingAnalyticsAPI.UserAppend( _properties, _dateTime ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.ThinkingAnalyticsAPI.UserAppend!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UserDelete_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 _appId = LuaAPI.lua_tostring(L, 1); + + ThinkingAnalytics.ThinkingAnalyticsAPI.UserDelete( _appId ); + + + + return 0; + } + if(gen_param_count == 0) + { + + ThinkingAnalytics.ThinkingAnalyticsAPI.UserDelete( ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + System.DateTime _dateTime;translator.Get(L, 1, out _dateTime); + string _appId = LuaAPI.lua_tostring(L, 2); + + ThinkingAnalytics.ThinkingAnalyticsAPI.UserDelete( _dateTime, _appId ); + + + + return 0; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + System.DateTime _dateTime;translator.Get(L, 1, out _dateTime); + + ThinkingAnalytics.ThinkingAnalyticsAPI.UserDelete( _dateTime ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.ThinkingAnalyticsAPI.UserDelete!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetNetworkType_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType _networkType;translator.Get(L, 1, out _networkType); + string _appId = LuaAPI.lua_tostring(L, 2); + + ThinkingAnalytics.ThinkingAnalyticsAPI.SetNetworkType( _networkType, _appId ); + + + + return 0; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType _networkType;translator.Get(L, 1, out _networkType); + + ThinkingAnalytics.ThinkingAnalyticsAPI.SetNetworkType( _networkType ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.ThinkingAnalyticsAPI.SetNetworkType!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetDeviceId_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = ThinkingAnalytics.ThinkingAnalyticsAPI.GetDeviceId( ); + 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 _m_SetDynamicSuperProperties_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + ThinkingAnalytics.IDynamicSuperProperties _dynamicSuperProperties = (ThinkingAnalytics.IDynamicSuperProperties)translator.GetObject(L, 1, typeof(ThinkingAnalytics.IDynamicSuperProperties)); + string _appId = LuaAPI.lua_tostring(L, 2); + + ThinkingAnalytics.ThinkingAnalyticsAPI.SetDynamicSuperProperties( _dynamicSuperProperties, _appId ); + + + + return 0; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + ThinkingAnalytics.IDynamicSuperProperties _dynamicSuperProperties = (ThinkingAnalytics.IDynamicSuperProperties)translator.GetObject(L, 1, typeof(ThinkingAnalytics.IDynamicSuperProperties)); + + ThinkingAnalytics.ThinkingAnalyticsAPI.SetDynamicSuperProperties( _dynamicSuperProperties ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.ThinkingAnalyticsAPI.SetDynamicSuperProperties!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OptOutTracking_xlua_st_(RealStatePtr L) + { + try { + + + + 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 _appId = LuaAPI.lua_tostring(L, 1); + + ThinkingAnalytics.ThinkingAnalyticsAPI.OptOutTracking( _appId ); + + + + return 0; + } + if(gen_param_count == 0) + { + + ThinkingAnalytics.ThinkingAnalyticsAPI.OptOutTracking( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.ThinkingAnalyticsAPI.OptOutTracking!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OptOutTrackingAndDeleteUser_xlua_st_(RealStatePtr L) + { + try { + + + + 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 _appId = LuaAPI.lua_tostring(L, 1); + + ThinkingAnalytics.ThinkingAnalyticsAPI.OptOutTrackingAndDeleteUser( _appId ); + + + + return 0; + } + if(gen_param_count == 0) + { + + ThinkingAnalytics.ThinkingAnalyticsAPI.OptOutTrackingAndDeleteUser( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.ThinkingAnalyticsAPI.OptOutTrackingAndDeleteUser!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OptInTracking_xlua_st_(RealStatePtr L) + { + try { + + + + 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 _appId = LuaAPI.lua_tostring(L, 1); + + ThinkingAnalytics.ThinkingAnalyticsAPI.OptInTracking( _appId ); + + + + return 0; + } + if(gen_param_count == 0) + { + + ThinkingAnalytics.ThinkingAnalyticsAPI.OptInTracking( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.ThinkingAnalyticsAPI.OptInTracking!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_EnableTracking_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + bool _enabled = LuaAPI.lua_toboolean(L, 1); + string _appId = LuaAPI.lua_tostring(L, 2); + + ThinkingAnalytics.ThinkingAnalyticsAPI.EnableTracking( _enabled, _appId ); + + + + return 0; + } + if(gen_param_count == 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)) + { + bool _enabled = LuaAPI.lua_toboolean(L, 1); + + ThinkingAnalytics.ThinkingAnalyticsAPI.EnableTracking( _enabled ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.ThinkingAnalyticsAPI.EnableTracking!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CreateLightInstance_xlua_st_(RealStatePtr L) + { + try { + + + + 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 _appId = LuaAPI.lua_tostring(L, 1); + + var gen_ret = ThinkingAnalytics.ThinkingAnalyticsAPI.CreateLightInstance( _appId ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 0) + { + + var gen_ret = ThinkingAnalytics.ThinkingAnalyticsAPI.CreateLightInstance( ); + LuaAPI.lua_pushstring(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 ThinkingAnalytics.ThinkingAnalyticsAPI.CreateLightInstance!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalibrateTime_xlua_st_(RealStatePtr L) + { + try { + + + + + { + long _timestamp = LuaAPI.lua_toint64(L, 1); + + ThinkingAnalytics.ThinkingAnalyticsAPI.CalibrateTime( _timestamp ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalibrateTimeWithNtp_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _ntpServer = LuaAPI.lua_tostring(L, 1); + + ThinkingAnalytics.ThinkingAnalyticsAPI.CalibrateTimeWithNtp( _ntpServer ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setDefaultAppid_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _appid = LuaAPI.lua_tostring(L, 1); + + ThinkingAnalytics.ThinkingAnalyticsAPI.setDefaultAppid( _appid ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_StartThinkingAnalytics_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + ThinkingAnalytics.ThinkingAnalyticsAPI.Token[] _tokens = (ThinkingAnalytics.ThinkingAnalyticsAPI.Token[])translator.GetObject(L, 1, typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.Token[])); + + ThinkingAnalytics.ThinkingAnalyticsAPI.StartThinkingAnalytics( _tokens ); + + + + return 0; + } + if(gen_param_count == 0) + { + + ThinkingAnalytics.ThinkingAnalyticsAPI.StartThinkingAnalytics( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.ThinkingAnalyticsAPI.StartThinkingAnalytics!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startManually(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.ThinkingAnalyticsAPI gen_to_be_invoked = (ThinkingAnalytics.ThinkingAnalyticsAPI)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.startManually); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enableLog(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.ThinkingAnalyticsAPI gen_to_be_invoked = (ThinkingAnalytics.ThinkingAnalyticsAPI)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.enableLog); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_networkType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.ThinkingAnalyticsAPI gen_to_be_invoked = (ThinkingAnalytics.ThinkingAnalyticsAPI)translator.FastGetCSObj(L, 1); + translator.PushThinkingAnalyticsThinkingAnalyticsAPINetworkType(L, gen_to_be_invoked.networkType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_tokens(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.ThinkingAnalyticsAPI gen_to_be_invoked = (ThinkingAnalytics.ThinkingAnalyticsAPI)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.tokens); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_VERSION(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.ThinkingAnalyticsAPI gen_to_be_invoked = (ThinkingAnalytics.ThinkingAnalyticsAPI)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.VERSION); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startManually(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.ThinkingAnalyticsAPI gen_to_be_invoked = (ThinkingAnalytics.ThinkingAnalyticsAPI)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.startManually = 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_enableLog(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.ThinkingAnalyticsAPI gen_to_be_invoked = (ThinkingAnalytics.ThinkingAnalyticsAPI)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.enableLog = 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_networkType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.ThinkingAnalyticsAPI gen_to_be_invoked = (ThinkingAnalytics.ThinkingAnalyticsAPI)translator.FastGetCSObj(L, 1); + ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.networkType = 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_tokens(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.ThinkingAnalyticsAPI gen_to_be_invoked = (ThinkingAnalytics.ThinkingAnalyticsAPI)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.tokens = (ThinkingAnalytics.ThinkingAnalyticsAPI.Token[])translator.GetObject(L, 2, typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.Token[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/ThinkingAnalytics_ThinkingAnalyticsAPI_TokenWrap.cs b/Assets/XLua/Gen/ThinkingAnalytics_ThinkingAnalyticsAPI_TokenWrap.cs new file mode 100644 index 000000000..8c4824653 --- /dev/null +++ b/Assets/XLua/Gen/ThinkingAnalytics_ThinkingAnalyticsAPI_TokenWrap.cs @@ -0,0 +1,305 @@ +#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 ThinkingAnalyticsThinkingAnalyticsAPITokenWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.Token); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 5, 5); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "getTimeZoneId", _m_getTimeZoneId); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "appid", _g_get_appid); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "serverUrl", _g_get_serverUrl); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mode", _g_get_mode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "timeZone", _g_get_timeZone); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "timeZoneId", _g_get_timeZoneId); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "appid", _s_set_appid); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "serverUrl", _s_set_serverUrl); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "mode", _s_set_mode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "timeZone", _s_set_timeZone); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "timeZoneId", _s_set_timeZoneId); + + + 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) == 6 && (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) && translator.Assignable(L, 4) && translator.Assignable(L, 5) && (LuaAPI.lua_isnil(L, 6) || LuaAPI.lua_type(L, 6) == LuaTypes.LUA_TSTRING)) + { + string _appId = LuaAPI.lua_tostring(L, 2); + string _serverUrl = LuaAPI.lua_tostring(L, 3); + ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode _mode;translator.Get(L, 4, out _mode); + ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone _timeZone;translator.Get(L, 5, out _timeZone); + string _timeZoneId = LuaAPI.lua_tostring(L, 6); + + var gen_ret = new ThinkingAnalytics.ThinkingAnalyticsAPI.Token(_appId, _serverUrl, _mode, _timeZone, _timeZoneId); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 5 && (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) && translator.Assignable(L, 4) && translator.Assignable(L, 5)) + { + string _appId = LuaAPI.lua_tostring(L, 2); + string _serverUrl = LuaAPI.lua_tostring(L, 3); + ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode _mode;translator.Get(L, 4, out _mode); + ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone _timeZone;translator.Get(L, 5, out _timeZone); + + var gen_ret = new ThinkingAnalytics.ThinkingAnalyticsAPI.Token(_appId, _serverUrl, _mode, _timeZone); + translator.Push(L, gen_ret); + + return 1; + } + + if (LuaAPI.lua_gettop(L) == 1) + { + translator.Push(L, default(ThinkingAnalytics.ThinkingAnalyticsAPI.Token)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.ThinkingAnalyticsAPI.Token constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_getTimeZoneId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.ThinkingAnalyticsAPI.Token gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.getTimeZoneId( ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_appid(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.ThinkingAnalyticsAPI.Token gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.appid); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_serverUrl(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.ThinkingAnalyticsAPI.Token gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.serverUrl); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.ThinkingAnalyticsAPI.Token gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushThinkingAnalyticsThinkingAnalyticsAPITAMode(L, gen_to_be_invoked.mode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_timeZone(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.ThinkingAnalyticsAPI.Token gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushThinkingAnalyticsThinkingAnalyticsAPITATimeZone(L, gen_to_be_invoked.timeZone); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_timeZoneId(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.ThinkingAnalyticsAPI.Token gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.timeZoneId); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_appid(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.ThinkingAnalyticsAPI.Token gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.appid = LuaAPI.lua_tostring(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_serverUrl(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.ThinkingAnalyticsAPI.Token gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.serverUrl = LuaAPI.lua_tostring(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_mode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.ThinkingAnalyticsAPI.Token gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.mode = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_timeZone(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.ThinkingAnalyticsAPI.Token gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.timeZone = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_timeZoneId(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.ThinkingAnalyticsAPI.Token gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.timeZoneId = LuaAPI.lua_tostring(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/ThinkingAnalytics_ThinkingAnalyticsEventWrap.cs b/Assets/XLua/Gen/ThinkingAnalytics_ThinkingAnalyticsEventWrap.cs new file mode 100644 index 000000000..a39bd59a6 --- /dev/null +++ b/Assets/XLua/Gen/ThinkingAnalytics_ThinkingAnalyticsEventWrap.cs @@ -0,0 +1,211 @@ +#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 ThinkingAnalyticsThinkingAnalyticsEventWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(ThinkingAnalytics.ThinkingAnalyticsEvent); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 5, 3); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "EventType", _g_get_EventType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "EventName", _g_get_EventName); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Properties", _g_get_Properties); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "EventTime", _g_get_EventTime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ExtraId", _g_get_ExtraId); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "EventType", _s_set_EventType); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "EventTime", _s_set_EventTime); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ExtraId", _s_set_ExtraId); + + + 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) && translator.Assignable>(L, 3)) + { + string _eventName = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 3, typeof(System.Collections.Generic.Dictionary)); + + var gen_ret = new ThinkingAnalytics.ThinkingAnalyticsEvent(_eventName, _properties); + 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 ThinkingAnalytics.ThinkingAnalyticsEvent constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_EventType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.ThinkingAnalyticsEvent gen_to_be_invoked = (ThinkingAnalytics.ThinkingAnalyticsEvent)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.EventType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_EventName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.ThinkingAnalyticsEvent gen_to_be_invoked = (ThinkingAnalytics.ThinkingAnalyticsEvent)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.EventName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Properties(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.ThinkingAnalyticsEvent gen_to_be_invoked = (ThinkingAnalytics.ThinkingAnalyticsEvent)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.Properties); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_EventTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.ThinkingAnalyticsEvent gen_to_be_invoked = (ThinkingAnalytics.ThinkingAnalyticsEvent)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.EventTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ExtraId(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.ThinkingAnalyticsEvent gen_to_be_invoked = (ThinkingAnalytics.ThinkingAnalyticsEvent)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.ExtraId); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_EventType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.ThinkingAnalyticsEvent gen_to_be_invoked = (ThinkingAnalytics.ThinkingAnalyticsEvent)translator.FastGetCSObj(L, 1); + System.Nullable gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.EventType = 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_EventTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.ThinkingAnalyticsEvent gen_to_be_invoked = (ThinkingAnalytics.ThinkingAnalyticsEvent)translator.FastGetCSObj(L, 1); + System.DateTime gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.EventTime = 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_ExtraId(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.ThinkingAnalyticsEvent gen_to_be_invoked = (ThinkingAnalytics.ThinkingAnalyticsEvent)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ExtraId = 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/ThinkingAnalytics_Utils_TD_LogWrap.cs b/Assets/XLua/Gen/ThinkingAnalytics_Utils_TD_LogWrap.cs new file mode 100644 index 000000000..65932f681 --- /dev/null +++ b/Assets/XLua/Gen/ThinkingAnalytics_Utils_TD_LogWrap.cs @@ -0,0 +1,184 @@ +#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 ThinkingAnalyticsUtilsTD_LogWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(ThinkingAnalytics.Utils.TD_Log); + 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, "EnableLog", _m_EnableLog_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "d", _m_d_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "e", _m_e_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "w", _m_w_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 ThinkingAnalytics.Utils.TD_Log(); + 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 ThinkingAnalytics.Utils.TD_Log constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_EnableLog_xlua_st_(RealStatePtr L) + { + try { + + + + + { + bool _enabled = LuaAPI.lua_toboolean(L, 1); + + ThinkingAnalytics.Utils.TD_Log.EnableLog( _enabled ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_d_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _message = LuaAPI.lua_tostring(L, 1); + + ThinkingAnalytics.Utils.TD_Log.d( _message ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_e_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _message = LuaAPI.lua_tostring(L, 1); + + ThinkingAnalytics.Utils.TD_Log.e( _message ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_w_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _message = LuaAPI.lua_tostring(L, 1); + + ThinkingAnalytics.Utils.TD_Log.w( _message ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/ThinkingAnalytics_Utils_TD_MiniJSONWrap.cs b/Assets/XLua/Gen/ThinkingAnalytics_Utils_TD_MiniJSONWrap.cs new file mode 100644 index 000000000..7a6b61eeb --- /dev/null +++ b/Assets/XLua/Gen/ThinkingAnalytics_Utils_TD_MiniJSONWrap.cs @@ -0,0 +1,156 @@ +#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 ThinkingAnalyticsUtilsTD_MiniJSONWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(ThinkingAnalytics.Utils.TD_MiniJSON); + 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) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new ThinkingAnalytics.Utils.TD_MiniJSON(); + 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 ThinkingAnalytics.Utils.TD_MiniJSON 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 = ThinkingAnalytics.Utils.TD_MiniJSON.Deserialize( _json ); + 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_Serialize_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable>(L, 2)) + { + object _obj = translator.GetObject(L, 1, typeof(object)); + System.Func _func = translator.GetDelegate>(L, 2); + + var gen_ret = ThinkingAnalytics.Utils.TD_MiniJSON.Serialize( _obj, _func ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _obj = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = ThinkingAnalytics.Utils.TD_MiniJSON.Serialize( _obj ); + LuaAPI.lua_pushstring(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 ThinkingAnalytics.Utils.TD_MiniJSON.Serialize!"); + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/ThinkingAnalytics_Utils_TD_PropertiesCheckerWrap.cs b/Assets/XLua/Gen/ThinkingAnalytics_Utils_TD_PropertiesCheckerWrap.cs new file mode 100644 index 000000000..46a161880 --- /dev/null +++ b/Assets/XLua/Gen/ThinkingAnalytics_Utils_TD_PropertiesCheckerWrap.cs @@ -0,0 +1,315 @@ +#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 ThinkingAnalyticsUtilsTD_PropertiesCheckerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(ThinkingAnalytics.Utils.TD_PropertiesChecker); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 8, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IsNumeric", _m_IsNumeric_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IsString", _m_IsString_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IsDictionary", _m_IsDictionary_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IsList", _m_IsList_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CheckProperties", _m_CheckProperties_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CheckString", _m_CheckString_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "MergeProperties", _m_MergeProperties_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 ThinkingAnalytics.Utils.TD_PropertiesChecker(); + 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 ThinkingAnalytics.Utils.TD_PropertiesChecker constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsNumeric_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + object _obj = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = ThinkingAnalytics.Utils.TD_PropertiesChecker.IsNumeric( _obj ); + 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_IsString_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + object _obj = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = ThinkingAnalytics.Utils.TD_PropertiesChecker.IsString( _obj ); + 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_IsDictionary_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + object _obj = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = ThinkingAnalytics.Utils.TD_PropertiesChecker.IsDictionary( _obj ); + 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_IsList_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + object _obj = translator.GetObject(L, 1, typeof(object)); + + var gen_ret = ThinkingAnalytics.Utils.TD_PropertiesChecker.IsList( _obj ); + 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_CheckProperties_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + double _properties = LuaAPI.lua_tonumber(L, 1); + + var gen_ret = ThinkingAnalytics.Utils.TD_PropertiesChecker.CheckProperties( _properties ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable>(L, 1)) + { + System.Collections.Generic.List _properties = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + + var gen_ret = ThinkingAnalytics.Utils.TD_PropertiesChecker.CheckProperties( _properties ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable>(L, 1)) + { + System.Collections.Generic.List _properties = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + + var gen_ret = ThinkingAnalytics.Utils.TD_PropertiesChecker.CheckProperties( _properties ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _properties = LuaAPI.lua_tostring(L, 1); + + var gen_ret = ThinkingAnalytics.Utils.TD_PropertiesChecker.CheckProperties( _properties ); + LuaAPI.lua_pushboolean(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 ThinkingAnalytics.Utils.TD_PropertiesChecker.CheckProperties!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CheckString_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _eventName = LuaAPI.lua_tostring(L, 1); + + var gen_ret = ThinkingAnalytics.Utils.TD_PropertiesChecker.CheckString( _eventName ); + 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_MergeProperties_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.Collections.Generic.Dictionary _source = (System.Collections.Generic.Dictionary)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary)); + System.Collections.Generic.Dictionary _dest = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + + ThinkingAnalytics.Utils.TD_PropertiesChecker.MergeProperties( _source, _dest ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/ThinkingAnalytics_Wrapper_ThinkingAnalyticsWrapperWrap.cs b/Assets/XLua/Gen/ThinkingAnalytics_Wrapper_ThinkingAnalyticsWrapperWrap.cs new file mode 100644 index 000000000..d6ee6db92 --- /dev/null +++ b/Assets/XLua/Gen/ThinkingAnalytics_Wrapper_ThinkingAnalyticsWrapperWrap.cs @@ -0,0 +1,1224 @@ +#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 ThinkingAnalyticsWrapperThinkingAnalyticsWrapperWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper); + Utils.BeginObjectRegister(type, L, translator, 0, 30, 2, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setDynamicSuperProperties", _m_setDynamicSuperProperties); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetDynamicSuperProperties", _m_GetDynamicSuperProperties); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Identify", _m_Identify); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetDistinctId", _m_GetDistinctId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Login", _m_Login); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Logout", _m_Logout); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "EnableAutoTrack", _m_EnableAutoTrack); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAutoTrackProperties", _m_SetAutoTrackProperties); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Track", _m_Track); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSuperProperties", _m_SetSuperProperties); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnsetSuperProperty", _m_UnsetSuperProperty); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearSuperProperty", _m_ClearSuperProperty); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TimeEvent", _m_TimeEvent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSuperProperties", _m_GetSuperProperties); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPresetProperties", _m_GetPresetProperties); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UserSet", _m_UserSet); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UserSetOnce", _m_UserSetOnce); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UserUnset", _m_UserUnset); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UserAdd", _m_UserAdd); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UserAppend", _m_UserAppend); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UserDelete", _m_UserDelete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Flush", _m_Flush); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetNetworkType", _m_SetNetworkType); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetDeviceId", _m_GetDeviceId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetDynamicSuperProperties", _m_SetDynamicSuperProperties); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OptOutTracking", _m_OptOutTracking); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OptOutTrackingAndDeleteUser", _m_OptOutTrackingAndDeleteUser); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OptInTracking", _m_OptInTracking); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "EnableTracking", _m_EnableTracking); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CreateLightInstance", _m_CreateLightInstance); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "taMono", _g_get_taMono); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "token", _g_get_token); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "taMono", _s_set_taMono); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 5, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "EnableLog", _m_EnableLog_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetVersionInfo", _m_SetVersionInfo_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CalibrateTime", _m_CalibrateTime_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CalibrateTimeWithNtp", _m_CalibrateTimeWithNtp_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) == 4 && translator.Assignable(L, 2) && translator.Assignable(L, 3) && LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + ThinkingAnalytics.ThinkingAnalyticsAPI.Token _token;translator.Get(L, 2, out _token); + UnityEngine.MonoBehaviour _mono = (UnityEngine.MonoBehaviour)translator.GetObject(L, 3, typeof(UnityEngine.MonoBehaviour)); + bool _initRequired = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = new ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper(_token, _mono, _initRequired); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 3 && translator.Assignable(L, 2) && translator.Assignable(L, 3)) + { + ThinkingAnalytics.ThinkingAnalyticsAPI.Token _token;translator.Get(L, 2, out _token); + UnityEngine.MonoBehaviour _mono = (UnityEngine.MonoBehaviour)translator.GetObject(L, 3, typeof(UnityEngine.MonoBehaviour)); + + var gen_ret = new ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper(_token, _mono); + 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 ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setDynamicSuperProperties(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + + { + ThinkingAnalytics.IDynamicSuperProperties _dynamicSuperProperties = (ThinkingAnalytics.IDynamicSuperProperties)translator.GetObject(L, 2, typeof(ThinkingAnalytics.IDynamicSuperProperties)); + + gen_to_be_invoked.setDynamicSuperProperties( _dynamicSuperProperties ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetDynamicSuperProperties(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetDynamicSuperProperties( ); + 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_EnableLog_xlua_st_(RealStatePtr L) + { + try { + + + + + { + bool _enableLog = LuaAPI.lua_toboolean(L, 1); + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper.EnableLog( _enableLog ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetVersionInfo_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _version = LuaAPI.lua_tostring(L, 1); + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper.SetVersionInfo( _version ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Identify(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + + { + string _uniqueId = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.Identify( _uniqueId ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetDistinctId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetDistinctId( ); + 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 _m_Login(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + + { + string _accountId = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.Login( _accountId ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Logout(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Logout( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_EnableAutoTrack(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + + { + ThinkingAnalytics.AUTO_TRACK_EVENTS _events;translator.Get(L, 2, out _events); + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 3, typeof(System.Collections.Generic.Dictionary)); + + gen_to_be_invoked.EnableAutoTrack( _events, _properties ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAutoTrackProperties(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + + { + ThinkingAnalytics.AUTO_TRACK_EVENTS _events;translator.Get(L, 2, out _events); + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 3, typeof(System.Collections.Generic.Dictionary)); + + gen_to_be_invoked.SetAutoTrackProperties( _events, _properties ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Track(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + ThinkingAnalytics.ThinkingAnalyticsEvent _taEvent = (ThinkingAnalytics.ThinkingAnalyticsEvent)translator.GetObject(L, 2, typeof(ThinkingAnalytics.ThinkingAnalyticsEvent)); + + gen_to_be_invoked.Track( _taEvent ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 3)) + { + string _eventName = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 3, typeof(System.Collections.Generic.Dictionary)); + + gen_to_be_invoked.Track( _eventName, _properties ); + + + + return 0; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 3)&& translator.Assignable(L, 4)) + { + string _eventName = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 3, typeof(System.Collections.Generic.Dictionary)); + System.DateTime _datetime;translator.Get(L, 4, out _datetime); + + gen_to_be_invoked.Track( _eventName, _properties, _datetime ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper.Track!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSuperProperties(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.Dictionary _superProperties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + + gen_to_be_invoked.SetSuperProperties( _superProperties ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UnsetSuperProperty(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + + { + string _superPropertyName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.UnsetSuperProperty( _superPropertyName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearSuperProperty(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearSuperProperty( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TimeEvent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + + { + string _eventName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.TimeEvent( _eventName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetSuperProperties(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetSuperProperties( ); + 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_GetPresetProperties(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetPresetProperties( ); + 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_UserSet(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + + gen_to_be_invoked.UserSet( _properties ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)) + { + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + System.DateTime _dateTime;translator.Get(L, 3, out _dateTime); + + gen_to_be_invoked.UserSet( _properties, _dateTime ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper.UserSet!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UserSetOnce(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + + gen_to_be_invoked.UserSetOnce( _properties ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)) + { + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + System.DateTime _dateTime;translator.Get(L, 3, out _dateTime); + + gen_to_be_invoked.UserSetOnce( _properties, _dateTime ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper.UserSetOnce!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UserUnset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.List _properties = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.UserUnset( _properties ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)) + { + System.Collections.Generic.List _properties = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + System.DateTime _dateTime;translator.Get(L, 3, out _dateTime); + + gen_to_be_invoked.UserUnset( _properties, _dateTime ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper.UserUnset!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UserAdd(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + + gen_to_be_invoked.UserAdd( _properties ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)) + { + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + System.DateTime _dateTime;translator.Get(L, 3, out _dateTime); + + gen_to_be_invoked.UserAdd( _properties, _dateTime ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper.UserAdd!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UserAppend(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + + gen_to_be_invoked.UserAppend( _properties ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)) + { + System.Collections.Generic.Dictionary _properties = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + System.DateTime _dateTime;translator.Get(L, 3, out _dateTime); + + gen_to_be_invoked.UserAppend( _properties, _dateTime ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper.UserAppend!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UserDelete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.UserDelete( ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.DateTime _dateTime;translator.Get(L, 2, out _dateTime); + + gen_to_be_invoked.UserDelete( _dateTime ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper.UserDelete!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Flush(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Flush( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetNetworkType(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + + { + ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType _networkType;translator.Get(L, 2, out _networkType); + + gen_to_be_invoked.SetNetworkType( _networkType ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetDeviceId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetDeviceId( ); + 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 _m_SetDynamicSuperProperties(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + + { + ThinkingAnalytics.IDynamicSuperProperties _dynamicSuperProperties = (ThinkingAnalytics.IDynamicSuperProperties)translator.GetObject(L, 2, typeof(ThinkingAnalytics.IDynamicSuperProperties)); + + gen_to_be_invoked.SetDynamicSuperProperties( _dynamicSuperProperties ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OptOutTracking(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.OptOutTracking( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OptOutTrackingAndDeleteUser(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.OptOutTrackingAndDeleteUser( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OptInTracking(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.OptInTracking( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_EnableTracking(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + + { + bool _enabled = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.EnableTracking( _enabled ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CreateLightInstance(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.CreateLightInstance( ); + 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_CalibrateTime_xlua_st_(RealStatePtr L) + { + try { + + + + + { + long _timestamp = LuaAPI.lua_toint64(L, 1); + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper.CalibrateTime( _timestamp ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalibrateTimeWithNtp_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _ntpServer = LuaAPI.lua_tostring(L, 1); + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper.CalibrateTimeWithNtp( _ntpServer ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_taMono(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.taMono); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_token(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.token); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_taMono(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper gen_to_be_invoked = (ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.taMono = (UnityEngine.MonoBehaviour)translator.GetObject(L, 2, typeof(UnityEngine.MonoBehaviour)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UIImageSheetAnimationWrap.cs b/Assets/XLua/Gen/UIImageSheetAnimationWrap.cs new file mode 100644 index 000000000..cc4f26140 --- /dev/null +++ b/Assets/XLua/Gen/UIImageSheetAnimationWrap.cs @@ -0,0 +1,522 @@ +#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 UIImageSheetAnimationWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UIImageSheetAnimation); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 14, 14); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lifeTime", _g_get_lifeTime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "loop", _g_get_loop); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sizeX", _g_get_sizeX); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sizeY", _g_get_sizeY); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startFrameMode", _g_get_startFrameMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startFrameMin", _g_get_startFrameMin); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startFrame", _g_get_startFrame); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "animationMode", _g_get_animationMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "randomRow", _g_get_randomRow); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "row", _g_get_row); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "timeMode", _g_get_timeMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "frameOverTime", _g_get_frameOverTime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "cycles", _g_get_cycles); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "FPS", _g_get_FPS); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "lifeTime", _s_set_lifeTime); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "loop", _s_set_loop); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sizeX", _s_set_sizeX); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sizeY", _s_set_sizeY); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startFrameMode", _s_set_startFrameMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startFrameMin", _s_set_startFrameMin); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startFrame", _s_set_startFrame); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "animationMode", _s_set_animationMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "randomRow", _s_set_randomRow); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "row", _s_set_row); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "timeMode", _s_set_timeMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "frameOverTime", _s_set_frameOverTime); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "cycles", _s_set_cycles); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "FPS", _s_set_FPS); + + + 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 UIImageSheetAnimation(); + 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 UIImageSheetAnimation constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lifeTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIImageSheetAnimation gen_to_be_invoked = (UIImageSheetAnimation)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.lifeTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_loop(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIImageSheetAnimation gen_to_be_invoked = (UIImageSheetAnimation)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.loop); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sizeX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIImageSheetAnimation gen_to_be_invoked = (UIImageSheetAnimation)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.sizeX); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sizeY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIImageSheetAnimation gen_to_be_invoked = (UIImageSheetAnimation)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.sizeY); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startFrameMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIImageSheetAnimation gen_to_be_invoked = (UIImageSheetAnimation)translator.FastGetCSObj(L, 1); + translator.PushUIImageSheetAnimationStartFrameType(L, gen_to_be_invoked.startFrameMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startFrameMin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIImageSheetAnimation gen_to_be_invoked = (UIImageSheetAnimation)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.startFrameMin); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startFrame(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIImageSheetAnimation gen_to_be_invoked = (UIImageSheetAnimation)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.startFrame); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_animationMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIImageSheetAnimation gen_to_be_invoked = (UIImageSheetAnimation)translator.FastGetCSObj(L, 1); + translator.PushUIImageSheetAnimationAnimationType(L, gen_to_be_invoked.animationMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_randomRow(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIImageSheetAnimation gen_to_be_invoked = (UIImageSheetAnimation)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.randomRow); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_row(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIImageSheetAnimation gen_to_be_invoked = (UIImageSheetAnimation)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.row); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_timeMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIImageSheetAnimation gen_to_be_invoked = (UIImageSheetAnimation)translator.FastGetCSObj(L, 1); + translator.PushUIImageSheetAnimationTimeType(L, gen_to_be_invoked.timeMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_frameOverTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIImageSheetAnimation gen_to_be_invoked = (UIImageSheetAnimation)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.frameOverTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cycles(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIImageSheetAnimation gen_to_be_invoked = (UIImageSheetAnimation)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.cycles); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_FPS(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIImageSheetAnimation gen_to_be_invoked = (UIImageSheetAnimation)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.FPS); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_lifeTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIImageSheetAnimation gen_to_be_invoked = (UIImageSheetAnimation)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.lifeTime = (float)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_loop(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIImageSheetAnimation gen_to_be_invoked = (UIImageSheetAnimation)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.loop = 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_sizeX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIImageSheetAnimation gen_to_be_invoked = (UIImageSheetAnimation)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.sizeX = 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_sizeY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIImageSheetAnimation gen_to_be_invoked = (UIImageSheetAnimation)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.sizeY = 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_startFrameMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIImageSheetAnimation gen_to_be_invoked = (UIImageSheetAnimation)translator.FastGetCSObj(L, 1); + UIImageSheetAnimation.StartFrameType gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.startFrameMode = 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_startFrameMin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIImageSheetAnimation gen_to_be_invoked = (UIImageSheetAnimation)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.startFrameMin = (float)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_startFrame(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIImageSheetAnimation gen_to_be_invoked = (UIImageSheetAnimation)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.startFrame = (float)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_animationMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIImageSheetAnimation gen_to_be_invoked = (UIImageSheetAnimation)translator.FastGetCSObj(L, 1); + UIImageSheetAnimation.AnimationType gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.animationMode = 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_randomRow(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIImageSheetAnimation gen_to_be_invoked = (UIImageSheetAnimation)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.randomRow = 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_row(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIImageSheetAnimation gen_to_be_invoked = (UIImageSheetAnimation)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.row = 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_timeMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIImageSheetAnimation gen_to_be_invoked = (UIImageSheetAnimation)translator.FastGetCSObj(L, 1); + UIImageSheetAnimation.TimeType gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.timeMode = 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_frameOverTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIImageSheetAnimation gen_to_be_invoked = (UIImageSheetAnimation)translator.FastGetCSObj(L, 1); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.frameOverTime = 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_cycles(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIImageSheetAnimation gen_to_be_invoked = (UIImageSheetAnimation)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.cycles = (float)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_FPS(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIImageSheetAnimation gen_to_be_invoked = (UIImageSheetAnimation)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.FPS = (float)LuaAPI.lua_tonumber(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UIInputHelperWrap.cs b/Assets/XLua/Gen/UIInputHelperWrap.cs new file mode 100644 index 000000000..f4afdee5f --- /dev/null +++ b/Assets/XLua/Gen/UIInputHelperWrap.cs @@ -0,0 +1,84 @@ +#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 UIInputHelperWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UIInputHelper); + 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) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new UIInputHelper(); + 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 UIInputHelper constructor!"); + + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UIOutlineEffectWrap.cs b/Assets/XLua/Gen/UIOutlineEffectWrap.cs new file mode 100644 index 000000000..fa18985bd --- /dev/null +++ b/Assets/XLua/Gen/UIOutlineEffectWrap.cs @@ -0,0 +1,176 @@ +#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 UIOutlineEffectWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UIOutlineEffect); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 2, 2); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ModifyMesh", _m_ModifyMesh); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "OutlineColor", _g_get_OutlineColor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "OutlineWidth", _g_get_OutlineWidth); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "OutlineColor", _s_set_OutlineColor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "OutlineWidth", _s_set_OutlineWidth); + + + 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 UIOutlineEffect(); + 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 UIOutlineEffect constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ModifyMesh(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UIOutlineEffect gen_to_be_invoked = (UIOutlineEffect)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.UI.VertexHelper _vh = (UnityEngine.UI.VertexHelper)translator.GetObject(L, 2, typeof(UnityEngine.UI.VertexHelper)); + + gen_to_be_invoked.ModifyMesh( _vh ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_OutlineColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIOutlineEffect gen_to_be_invoked = (UIOutlineEffect)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineColor(L, gen_to_be_invoked.OutlineColor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_OutlineWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIOutlineEffect gen_to_be_invoked = (UIOutlineEffect)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.OutlineWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_OutlineColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIOutlineEffect gen_to_be_invoked = (UIOutlineEffect)translator.FastGetCSObj(L, 1); + UnityEngine.Color gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.OutlineColor = 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_OutlineWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIOutlineEffect gen_to_be_invoked = (UIOutlineEffect)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.OutlineWidth = 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/UIResGhostTweenEffectWrap.cs b/Assets/XLua/Gen/UIResGhostTweenEffectWrap.cs new file mode 100644 index 000000000..ec0d1d830 --- /dev/null +++ b/Assets/XLua/Gen/UIResGhostTweenEffectWrap.cs @@ -0,0 +1,144 @@ +#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 UIResGhostTweenEffectWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UIResGhostTweenEffect); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 1, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMaterial", _m_SetMaterial); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "smooth", _g_get_smooth); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "smooth", _s_set_smooth); + + + 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 UIResGhostTweenEffect(); + 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 UIResGhostTweenEffect constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMaterial(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UIResGhostTweenEffect gen_to_be_invoked = (UIResGhostTweenEffect)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + gen_to_be_invoked.SetMaterial( _material ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_smooth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIResGhostTweenEffect gen_to_be_invoked = (UIResGhostTweenEffect)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.smooth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_smooth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UIResGhostTweenEffect gen_to_be_invoked = (UIResGhostTweenEffect)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.smooth = (float)LuaAPI.lua_tonumber(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_AnimationClipWrap.cs b/Assets/XLua/Gen/UnityEngine_AnimationClipWrap.cs new file mode 100644 index 000000000..87c95c60a --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_AnimationClipWrap.cs @@ -0,0 +1,493 @@ +#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 UnityEngineAnimationClipWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.AnimationClip); + Utils.BeginObjectRegister(type, L, translator, 0, 5, 12, 5); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SampleAnimation", _m_SampleAnimation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetCurve", _m_SetCurve); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "EnsureQuaternionContinuity", _m_EnsureQuaternionContinuity); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearCurves", _m_ClearCurves); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddEvent", _m_AddEvent); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "length", _g_get_length); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "frameRate", _g_get_frameRate); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "wrapMode", _g_get_wrapMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "localBounds", _g_get_localBounds); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "legacy", _g_get_legacy); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "humanMotion", _g_get_humanMotion); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "empty", _g_get_empty); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "hasGenericRootTransform", _g_get_hasGenericRootTransform); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "hasMotionFloatCurves", _g_get_hasMotionFloatCurves); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "hasMotionCurves", _g_get_hasMotionCurves); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "hasRootCurves", _g_get_hasRootCurves); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "events", _g_get_events); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "frameRate", _s_set_frameRate); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "wrapMode", _s_set_wrapMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "localBounds", _s_set_localBounds); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "legacy", _s_set_legacy); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "events", _s_set_events); + + + 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 UnityEngine.AnimationClip(); + 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 UnityEngine.AnimationClip constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SampleAnimation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.GameObject _go = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + float _time = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SampleAnimation( _go, _time ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetCurve(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1); + + + + { + string _relativePath = LuaAPI.lua_tostring(L, 2); + System.Type _type = (System.Type)translator.GetObject(L, 3, typeof(System.Type)); + string _propertyName = LuaAPI.lua_tostring(L, 4); + UnityEngine.AnimationCurve _curve = (UnityEngine.AnimationCurve)translator.GetObject(L, 5, typeof(UnityEngine.AnimationCurve)); + + gen_to_be_invoked.SetCurve( _relativePath, _type, _propertyName, _curve ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_EnsureQuaternionContinuity(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.EnsureQuaternionContinuity( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearCurves(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearCurves( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddEvent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.AnimationEvent _evt = (UnityEngine.AnimationEvent)translator.GetObject(L, 2, typeof(UnityEngine.AnimationEvent)); + + gen_to_be_invoked.AddEvent( _evt ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_length(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.length); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_frameRate(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.frameRate); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_wrapMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.wrapMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_localBounds(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineBounds(L, gen_to_be_invoked.localBounds); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_legacy(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.legacy); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_humanMotion(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.humanMotion); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_empty(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.empty); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_hasGenericRootTransform(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hasGenericRootTransform); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_hasMotionFloatCurves(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hasMotionFloatCurves); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_hasMotionCurves(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hasMotionCurves); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_hasRootCurves(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hasRootCurves); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_events(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.events); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_frameRate(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.frameRate = (float)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_wrapMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1); + UnityEngine.WrapMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.wrapMode = 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_localBounds(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1); + UnityEngine.Bounds gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.localBounds = 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_legacy(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.legacy = 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_events(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimationClip gen_to_be_invoked = (UnityEngine.AnimationClip)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.events = (UnityEngine.AnimationEvent[])translator.GetObject(L, 2, typeof(UnityEngine.AnimationEvent[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_AnimationCurveWrap.cs b/Assets/XLua/Gen/UnityEngine_AnimationCurveWrap.cs new file mode 100644 index 000000000..87267cff2 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_AnimationCurveWrap.cs @@ -0,0 +1,560 @@ +#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 UnityEngineAnimationCurveWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.AnimationCurve); + Utils.BeginObjectRegister(type, L, translator, 0, 7, 4, 3); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Evaluate", _m_Evaluate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddKey", _m_AddKey); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "MoveKey", _m_MoveKey); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveKey", _m_RemoveKey); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SmoothTangents", _m_SmoothTangents); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Equals", _m_Equals); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashCode", _m_GetHashCode); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "keys", _g_get_keys); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "length", _g_get_length); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preWrapMode", _g_get_preWrapMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "postWrapMode", _g_get_postWrapMode); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "keys", _s_set_keys); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "preWrapMode", _s_set_preWrapMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "postWrapMode", _s_set_postWrapMode); + + + Utils.EndObjectRegister(type, L, translator, __CSIndexer, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 4, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Constant", _m_Constant_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Linear", _m_Linear_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "EaseInOut", _m_EaseInOut_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 && (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 2) || translator.Assignable(L, 2))) + { + UnityEngine.Keyframe[] _keys = translator.GetParams(L, 2); + + var gen_ret = new UnityEngine.AnimationCurve(_keys); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new UnityEngine.AnimationCurve(); + 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 UnityEngine.AnimationCurve constructor!"); + + } + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __CSIndexer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + if (translator.Assignable(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + + UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1); + int index = LuaAPI.xlua_tointeger(L, 2); + LuaAPI.lua_pushboolean(L, true); + translator.Push(L, gen_to_be_invoked[index]); + return 2; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Evaluate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1); + + + + { + float _time = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.Evaluate( _time ); + LuaAPI.lua_pushnumber(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_AddKey(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _time = (float)LuaAPI.lua_tonumber(L, 2); + float _value = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.AddKey( _time, _value ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Keyframe _key;translator.Get(L, 2, out _key); + + var gen_ret = gen_to_be_invoked.AddKey( _key ); + LuaAPI.xlua_pushinteger(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 UnityEngine.AnimationCurve.AddKey!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_MoveKey(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Keyframe _key;translator.Get(L, 3, out _key); + + var gen_ret = gen_to_be_invoked.MoveKey( _index, _key ); + 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_RemoveKey(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.RemoveKey( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SmoothTangents(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _weight = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SmoothTangents( _index, _weight ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Constant_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + float _timeStart = (float)LuaAPI.lua_tonumber(L, 1); + float _timeEnd = (float)LuaAPI.lua_tonumber(L, 2); + float _value = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.AnimationCurve.Constant( _timeStart, _timeEnd, _value ); + 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_Linear_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + float _timeStart = (float)LuaAPI.lua_tonumber(L, 1); + float _valueStart = (float)LuaAPI.lua_tonumber(L, 2); + float _timeEnd = (float)LuaAPI.lua_tonumber(L, 3); + float _valueEnd = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = UnityEngine.AnimationCurve.Linear( _timeStart, _valueStart, _timeEnd, _valueEnd ); + 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_EaseInOut_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + float _timeStart = (float)LuaAPI.lua_tonumber(L, 1); + float _valueStart = (float)LuaAPI.lua_tonumber(L, 2); + float _timeEnd = (float)LuaAPI.lua_tonumber(L, 3); + float _valueEnd = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = UnityEngine.AnimationCurve.EaseInOut( _timeStart, _valueStart, _timeEnd, _valueEnd ); + 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_Equals(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _o = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.Equals( _o ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.AnimationCurve _other = (UnityEngine.AnimationCurve)translator.GetObject(L, 2, typeof(UnityEngine.AnimationCurve)); + + var gen_ret = gen_to_be_invoked.Equals( _other ); + LuaAPI.lua_pushboolean(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 UnityEngine.AnimationCurve.Equals!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetHashCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetHashCode( ); + 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 _g_get_keys(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.keys); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_length(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.length); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preWrapMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.preWrapMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_postWrapMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.postWrapMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_keys(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.keys = (UnityEngine.Keyframe[])translator.GetObject(L, 2, typeof(UnityEngine.Keyframe[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_preWrapMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1); + UnityEngine.WrapMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.preWrapMode = 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_postWrapMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimationCurve gen_to_be_invoked = (UnityEngine.AnimationCurve)translator.FastGetCSObj(L, 1); + UnityEngine.WrapMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.postWrapMode = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_AnimationWrap.cs b/Assets/XLua/Gen/UnityEngine_AnimationWrap.cs new file mode 100644 index 000000000..c2be2fd8c --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_AnimationWrap.cs @@ -0,0 +1,991 @@ +#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 UnityEngineAnimationWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Animation); + Utils.BeginObjectRegister(type, L, translator, 0, 16, 7, 6); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Stop", _m_Stop); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Rewind", _m_Rewind); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Sample", _m_Sample); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsPlaying", _m_IsPlaying); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "get_Item", _m_get_Item); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Play", _m_Play); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CrossFade", _m_CrossFade); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Blend", _m_Blend); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CrossFadeQueued", _m_CrossFadeQueued); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PlayQueued", _m_PlayQueued); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddClip", _m_AddClip); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveClip", _m_RemoveClip); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetClipCount", _m_GetClipCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SyncLayer", _m_SyncLayer); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetEnumerator", _m_GetEnumerator); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetClip", _m_GetClip); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "clip", _g_get_clip); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "playAutomatically", _g_get_playAutomatically); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "wrapMode", _g_get_wrapMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isPlaying", _g_get_isPlaying); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "animatePhysics", _g_get_animatePhysics); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "cullingType", _g_get_cullingType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "localBounds", _g_get_localBounds); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "clip", _s_set_clip); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "playAutomatically", _s_set_playAutomatically); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "wrapMode", _s_set_wrapMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "animatePhysics", _s_set_animatePhysics); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "cullingType", _s_set_cullingType); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "localBounds", _s_set_localBounds); + + + 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 UnityEngine.Animation(); + 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 UnityEngine.Animation constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Stop(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animation gen_to_be_invoked = (UnityEngine.Animation)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.Stop( ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.Stop( _name ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Animation.Stop!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Rewind(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animation gen_to_be_invoked = (UnityEngine.Animation)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.Rewind( ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.Rewind( _name ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Animation.Rewind!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Sample(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animation gen_to_be_invoked = (UnityEngine.Animation)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Sample( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsPlaying(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animation gen_to_be_invoked = (UnityEngine.Animation)translator.FastGetCSObj(L, 1); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.IsPlaying( _name ); + 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_get_Item(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animation gen_to_be_invoked = (UnityEngine.Animation)translator.FastGetCSObj(L, 1); + + + + { + + string key = LuaAPI.lua_tostring(L, 2); + translator.Push(L, gen_to_be_invoked[key]); + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Play(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animation gen_to_be_invoked = (UnityEngine.Animation)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.Play( ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.PlayMode _mode;translator.Get(L, 2, out _mode); + + var gen_ret = gen_to_be_invoked.Play( _mode ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _animation = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.Play( _animation ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _animation = LuaAPI.lua_tostring(L, 2); + UnityEngine.PlayMode _mode;translator.Get(L, 3, out _mode); + + var gen_ret = gen_to_be_invoked.Play( _animation, _mode ); + LuaAPI.lua_pushboolean(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 UnityEngine.Animation.Play!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CrossFade(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animation gen_to_be_invoked = (UnityEngine.Animation)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _animation = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.CrossFade( _animation ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + string _animation = LuaAPI.lua_tostring(L, 2); + float _fadeLength = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.CrossFade( _animation, _fadeLength ); + + + + return 0; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + string _animation = LuaAPI.lua_tostring(L, 2); + float _fadeLength = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.PlayMode _mode;translator.Get(L, 4, out _mode); + + gen_to_be_invoked.CrossFade( _animation, _fadeLength, _mode ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Animation.CrossFade!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Blend(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animation gen_to_be_invoked = (UnityEngine.Animation)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _animation = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.Blend( _animation ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + string _animation = LuaAPI.lua_tostring(L, 2); + float _targetWeight = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.Blend( _animation, _targetWeight ); + + + + return 0; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + string _animation = LuaAPI.lua_tostring(L, 2); + float _targetWeight = (float)LuaAPI.lua_tonumber(L, 3); + float _fadeLength = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.Blend( _animation, _targetWeight, _fadeLength ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Animation.Blend!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CrossFadeQueued(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animation gen_to_be_invoked = (UnityEngine.Animation)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _animation = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.CrossFadeQueued( _animation ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + string _animation = LuaAPI.lua_tostring(L, 2); + float _fadeLength = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.CrossFadeQueued( _animation, _fadeLength ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + string _animation = LuaAPI.lua_tostring(L, 2); + float _fadeLength = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.QueueMode _queue;translator.Get(L, 4, out _queue); + + var gen_ret = gen_to_be_invoked.CrossFadeQueued( _animation, _fadeLength, _queue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)) + { + string _animation = LuaAPI.lua_tostring(L, 2); + float _fadeLength = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.QueueMode _queue;translator.Get(L, 4, out _queue); + UnityEngine.PlayMode _mode;translator.Get(L, 5, out _mode); + + var gen_ret = gen_to_be_invoked.CrossFadeQueued( _animation, _fadeLength, _queue, _mode ); + 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 UnityEngine.Animation.CrossFadeQueued!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PlayQueued(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animation gen_to_be_invoked = (UnityEngine.Animation)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _animation = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.PlayQueued( _animation ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _animation = LuaAPI.lua_tostring(L, 2); + UnityEngine.QueueMode _queue;translator.Get(L, 3, out _queue); + + var gen_ret = gen_to_be_invoked.PlayQueued( _animation, _queue ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + string _animation = LuaAPI.lua_tostring(L, 2); + UnityEngine.QueueMode _queue;translator.Get(L, 3, out _queue); + UnityEngine.PlayMode _mode;translator.Get(L, 4, out _mode); + + var gen_ret = gen_to_be_invoked.PlayQueued( _animation, _queue, _mode ); + 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 UnityEngine.Animation.PlayQueued!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddClip(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animation gen_to_be_invoked = (UnityEngine.Animation)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + UnityEngine.AnimationClip _clip = (UnityEngine.AnimationClip)translator.GetObject(L, 2, typeof(UnityEngine.AnimationClip)); + string _newName = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.AddClip( _clip, _newName ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.AnimationClip _clip = (UnityEngine.AnimationClip)translator.GetObject(L, 2, typeof(UnityEngine.AnimationClip)); + string _newName = LuaAPI.lua_tostring(L, 3); + int _firstFrame = LuaAPI.xlua_tointeger(L, 4); + int _lastFrame = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.AddClip( _clip, _newName, _firstFrame, _lastFrame ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)) + { + UnityEngine.AnimationClip _clip = (UnityEngine.AnimationClip)translator.GetObject(L, 2, typeof(UnityEngine.AnimationClip)); + string _newName = LuaAPI.lua_tostring(L, 3); + int _firstFrame = LuaAPI.xlua_tointeger(L, 4); + int _lastFrame = LuaAPI.xlua_tointeger(L, 5); + bool _addLoopFrame = LuaAPI.lua_toboolean(L, 6); + + gen_to_be_invoked.AddClip( _clip, _newName, _firstFrame, _lastFrame, _addLoopFrame ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Animation.AddClip!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveClip(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animation gen_to_be_invoked = (UnityEngine.Animation)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.AnimationClip _clip = (UnityEngine.AnimationClip)translator.GetObject(L, 2, typeof(UnityEngine.AnimationClip)); + + gen_to_be_invoked.RemoveClip( _clip ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _clipName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.RemoveClip( _clipName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Animation.RemoveClip!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetClipCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animation gen_to_be_invoked = (UnityEngine.Animation)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetClipCount( ); + 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_SyncLayer(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animation gen_to_be_invoked = (UnityEngine.Animation)translator.FastGetCSObj(L, 1); + + + + { + int _layer = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SyncLayer( _layer ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetEnumerator(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animation gen_to_be_invoked = (UnityEngine.Animation)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetEnumerator( ); + 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_GetClip(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animation gen_to_be_invoked = (UnityEngine.Animation)translator.FastGetCSObj(L, 1); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetClip( _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 _g_get_clip(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animation gen_to_be_invoked = (UnityEngine.Animation)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.clip); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_playAutomatically(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animation gen_to_be_invoked = (UnityEngine.Animation)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.playAutomatically); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_wrapMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animation gen_to_be_invoked = (UnityEngine.Animation)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.wrapMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isPlaying(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animation gen_to_be_invoked = (UnityEngine.Animation)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isPlaying); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_animatePhysics(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animation gen_to_be_invoked = (UnityEngine.Animation)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.animatePhysics); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cullingType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animation gen_to_be_invoked = (UnityEngine.Animation)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.cullingType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_localBounds(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animation gen_to_be_invoked = (UnityEngine.Animation)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineBounds(L, gen_to_be_invoked.localBounds); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_clip(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animation gen_to_be_invoked = (UnityEngine.Animation)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.clip = (UnityEngine.AnimationClip)translator.GetObject(L, 2, typeof(UnityEngine.AnimationClip)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_playAutomatically(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animation gen_to_be_invoked = (UnityEngine.Animation)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.playAutomatically = 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_wrapMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animation gen_to_be_invoked = (UnityEngine.Animation)translator.FastGetCSObj(L, 1); + UnityEngine.WrapMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.wrapMode = 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_animatePhysics(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animation gen_to_be_invoked = (UnityEngine.Animation)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.animatePhysics = 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_cullingType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animation gen_to_be_invoked = (UnityEngine.Animation)translator.FastGetCSObj(L, 1); + UnityEngine.AnimationCullingType gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.cullingType = 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_localBounds(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animation gen_to_be_invoked = (UnityEngine.Animation)translator.FastGetCSObj(L, 1); + UnityEngine.Bounds gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.localBounds = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_AnimatorStateInfoWrap.cs b/Assets/XLua/Gen/UnityEngine_AnimatorStateInfoWrap.cs new file mode 100644 index 000000000..88143150f --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_AnimatorStateInfoWrap.cs @@ -0,0 +1,266 @@ +#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 UnityEngineAnimatorStateInfoWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.AnimatorStateInfo); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 8, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsName", _m_IsName); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsTag", _m_IsTag); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fullPathHash", _g_get_fullPathHash); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "shortNameHash", _g_get_shortNameHash); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "normalizedTime", _g_get_normalizedTime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "length", _g_get_length); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "speed", _g_get_speed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "speedMultiplier", _g_get_speedMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "tagHash", _g_get_tagHash); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "loop", _g_get_loop); + + + + 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) + { + translator.Push(L, default(UnityEngine.AnimatorStateInfo)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.AnimatorStateInfo constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsName(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AnimatorStateInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.IsName( _name ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsTag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AnimatorStateInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + string _tag = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.IsTag( _tag ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fullPathHash(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimatorStateInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.fullPathHash); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_shortNameHash(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimatorStateInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.shortNameHash); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_normalizedTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimatorStateInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.normalizedTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_length(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimatorStateInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.length); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_speed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimatorStateInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.speed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_speedMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimatorStateInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.speedMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_tagHash(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimatorStateInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.tagHash); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_loop(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AnimatorStateInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.loop); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_AnimatorWrap.cs b/Assets/XLua/Gen/UnityEngine_AnimatorWrap.cs new file mode 100644 index 000000000..aa1380c09 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_AnimatorWrap.cs @@ -0,0 +1,3327 @@ +#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 UnityEngineAnimatorWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Animator); + Utils.BeginObjectRegister(type, L, translator, 0, 55, 44, 20); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetFloat", _m_GetFloat); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetFloat", _m_SetFloat); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetBool", _m_GetBool); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetBool", _m_SetBool); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetInteger", _m_GetInteger); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetInteger", _m_SetInteger); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTrigger", _m_SetTrigger); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetTrigger", _m_ResetTrigger); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsParameterControlledByCurve", _m_IsParameterControlledByCurve); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetIKPosition", _m_GetIKPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetIKPosition", _m_SetIKPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetIKRotation", _m_GetIKRotation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetIKRotation", _m_SetIKRotation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetIKPositionWeight", _m_GetIKPositionWeight); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetIKPositionWeight", _m_SetIKPositionWeight); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetIKRotationWeight", _m_GetIKRotationWeight); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetIKRotationWeight", _m_SetIKRotationWeight); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetIKHintPosition", _m_GetIKHintPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetIKHintPosition", _m_SetIKHintPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetIKHintPositionWeight", _m_GetIKHintPositionWeight); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetIKHintPositionWeight", _m_SetIKHintPositionWeight); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLookAtPosition", _m_SetLookAtPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLookAtWeight", _m_SetLookAtWeight); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetBoneLocalRotation", _m_SetBoneLocalRotation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetBehaviours", _m_GetBehaviours); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetLayerName", _m_GetLayerName); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetLayerIndex", _m_GetLayerIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetLayerWeight", _m_GetLayerWeight); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLayerWeight", _m_SetLayerWeight); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetCurrentAnimatorStateInfo", _m_GetCurrentAnimatorStateInfo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNextAnimatorStateInfo", _m_GetNextAnimatorStateInfo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAnimatorTransitionInfo", _m_GetAnimatorTransitionInfo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetCurrentAnimatorClipInfoCount", _m_GetCurrentAnimatorClipInfoCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNextAnimatorClipInfoCount", _m_GetNextAnimatorClipInfoCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetCurrentAnimatorClipInfo", _m_GetCurrentAnimatorClipInfo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNextAnimatorClipInfo", _m_GetNextAnimatorClipInfo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsInTransition", _m_IsInTransition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetParameter", _m_GetParameter); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "MatchTarget", _m_MatchTarget); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InterruptMatchTarget", _m_InterruptMatchTarget); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CrossFadeInFixedTime", _m_CrossFadeInFixedTime); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "WriteDefaultValues", _m_WriteDefaultValues); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CrossFade", _m_CrossFade); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PlayInFixedTime", _m_PlayInFixedTime); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Play", _m_Play); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTarget", _m_SetTarget); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetBoneTransform", _m_GetBoneTransform); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "StartPlayback", _m_StartPlayback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "StopPlayback", _m_StopPlayback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "StartRecording", _m_StartRecording); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "StopRecording", _m_StopRecording); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasState", _m_HasState); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Update", _m_Update); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Rebind", _m_Rebind); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ApplyBuiltinRootMotion", _m_ApplyBuiltinRootMotion); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isOptimizable", _g_get_isOptimizable); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isHuman", _g_get_isHuman); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "hasRootMotion", _g_get_hasRootMotion); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "humanScale", _g_get_humanScale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isInitialized", _g_get_isInitialized); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "deltaPosition", _g_get_deltaPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "deltaRotation", _g_get_deltaRotation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "velocity", _g_get_velocity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "angularVelocity", _g_get_angularVelocity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rootPosition", _g_get_rootPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rootRotation", _g_get_rootRotation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "applyRootMotion", _g_get_applyRootMotion); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "updateMode", _g_get_updateMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "hasTransformHierarchy", _g_get_hasTransformHierarchy); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "gravityWeight", _g_get_gravityWeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bodyPosition", _g_get_bodyPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bodyRotation", _g_get_bodyRotation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "stabilizeFeet", _g_get_stabilizeFeet); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "layerCount", _g_get_layerCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "parameters", _g_get_parameters); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "parameterCount", _g_get_parameterCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "feetPivotActive", _g_get_feetPivotActive); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "pivotWeight", _g_get_pivotWeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "pivotPosition", _g_get_pivotPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isMatchingTarget", _g_get_isMatchingTarget); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "speed", _g_get_speed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "targetPosition", _g_get_targetPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "targetRotation", _g_get_targetRotation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "cullingMode", _g_get_cullingMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "playbackTime", _g_get_playbackTime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "recorderStartTime", _g_get_recorderStartTime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "recorderStopTime", _g_get_recorderStopTime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "recorderMode", _g_get_recorderMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "runtimeAnimatorController", _g_get_runtimeAnimatorController); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "hasBoundPlayables", _g_get_hasBoundPlayables); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "avatar", _g_get_avatar); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "playableGraph", _g_get_playableGraph); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "layersAffectMassCenter", _g_get_layersAffectMassCenter); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "leftFeetBottomHeight", _g_get_leftFeetBottomHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rightFeetBottomHeight", _g_get_rightFeetBottomHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "logWarnings", _g_get_logWarnings); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fireEvents", _g_get_fireEvents); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "keepAnimatorStateOnDisable", _g_get_keepAnimatorStateOnDisable); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "writeDefaultValuesOnDisable", _g_get_writeDefaultValuesOnDisable); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "rootPosition", _s_set_rootPosition); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "rootRotation", _s_set_rootRotation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "applyRootMotion", _s_set_applyRootMotion); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "updateMode", _s_set_updateMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "bodyPosition", _s_set_bodyPosition); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "bodyRotation", _s_set_bodyRotation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "stabilizeFeet", _s_set_stabilizeFeet); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "feetPivotActive", _s_set_feetPivotActive); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "speed", _s_set_speed); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "cullingMode", _s_set_cullingMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "playbackTime", _s_set_playbackTime); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "recorderStartTime", _s_set_recorderStartTime); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "recorderStopTime", _s_set_recorderStopTime); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "runtimeAnimatorController", _s_set_runtimeAnimatorController); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "avatar", _s_set_avatar); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "layersAffectMassCenter", _s_set_layersAffectMassCenter); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "logWarnings", _s_set_logWarnings); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fireEvents", _s_set_fireEvents); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "keepAnimatorStateOnDisable", _s_set_keepAnimatorStateOnDisable); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "writeDefaultValuesOnDisable", _s_set_writeDefaultValuesOnDisable); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "StringToHash", _m_StringToHash_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 UnityEngine.Animator(); + 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 UnityEngine.Animator constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetFloat(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _id = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetFloat( _id ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetFloat( _name ); + LuaAPI.lua_pushnumber(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 UnityEngine.Animator.GetFloat!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetFloat(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _id = LuaAPI.xlua_tointeger(L, 2); + float _value = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetFloat( _id, _value ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int _id = LuaAPI.xlua_tointeger(L, 2); + float _value = (float)LuaAPI.lua_tonumber(L, 3); + float _dampTime = (float)LuaAPI.lua_tonumber(L, 4); + float _deltaTime = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.SetFloat( _id, _value, _dampTime, _deltaTime ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + float _value = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetFloat( _name, _value ); + + + + return 0; + } + if(gen_param_count == 5&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + string _name = LuaAPI.lua_tostring(L, 2); + float _value = (float)LuaAPI.lua_tonumber(L, 3); + float _dampTime = (float)LuaAPI.lua_tonumber(L, 4); + float _deltaTime = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.SetFloat( _name, _value, _dampTime, _deltaTime ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Animator.SetFloat!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetBool(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _id = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetBool( _id ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetBool( _name ); + LuaAPI.lua_pushboolean(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 UnityEngine.Animator.GetBool!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetBool(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + int _id = LuaAPI.xlua_tointeger(L, 2); + bool _value = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.SetBool( _id, _value ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + bool _value = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.SetBool( _name, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Animator.SetBool!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetInteger(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _id = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetInteger( _id ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetInteger( _name ); + LuaAPI.xlua_pushinteger(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 UnityEngine.Animator.GetInteger!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetInteger(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _id = LuaAPI.xlua_tointeger(L, 2); + int _value = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetInteger( _id, _value ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + int _value = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetInteger( _name, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Animator.SetInteger!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTrigger(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _id = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetTrigger( _id ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SetTrigger( _name ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Animator.SetTrigger!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetTrigger(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _id = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.ResetTrigger( _id ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.ResetTrigger( _name ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Animator.ResetTrigger!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsParameterControlledByCurve(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _id = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.IsParameterControlledByCurve( _id ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.IsParameterControlledByCurve( _name ); + LuaAPI.lua_pushboolean(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 UnityEngine.Animator.IsParameterControlledByCurve!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetIKPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.AvatarIKGoal _goal;translator.Get(L, 2, out _goal); + + var gen_ret = gen_to_be_invoked.GetIKPosition( _goal ); + translator.PushUnityEngineVector3(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_SetIKPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.AvatarIKGoal _goal;translator.Get(L, 2, out _goal); + UnityEngine.Vector3 _goalPosition;translator.Get(L, 3, out _goalPosition); + + gen_to_be_invoked.SetIKPosition( _goal, _goalPosition ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetIKRotation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.AvatarIKGoal _goal;translator.Get(L, 2, out _goal); + + var gen_ret = gen_to_be_invoked.GetIKRotation( _goal ); + translator.PushUnityEngineQuaternion(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_SetIKRotation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.AvatarIKGoal _goal;translator.Get(L, 2, out _goal); + UnityEngine.Quaternion _goalRotation;translator.Get(L, 3, out _goalRotation); + + gen_to_be_invoked.SetIKRotation( _goal, _goalRotation ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetIKPositionWeight(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.AvatarIKGoal _goal;translator.Get(L, 2, out _goal); + + var gen_ret = gen_to_be_invoked.GetIKPositionWeight( _goal ); + LuaAPI.lua_pushnumber(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_SetIKPositionWeight(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.AvatarIKGoal _goal;translator.Get(L, 2, out _goal); + float _value = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetIKPositionWeight( _goal, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetIKRotationWeight(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.AvatarIKGoal _goal;translator.Get(L, 2, out _goal); + + var gen_ret = gen_to_be_invoked.GetIKRotationWeight( _goal ); + LuaAPI.lua_pushnumber(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_SetIKRotationWeight(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.AvatarIKGoal _goal;translator.Get(L, 2, out _goal); + float _value = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetIKRotationWeight( _goal, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetIKHintPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.AvatarIKHint _hint;translator.Get(L, 2, out _hint); + + var gen_ret = gen_to_be_invoked.GetIKHintPosition( _hint ); + translator.PushUnityEngineVector3(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_SetIKHintPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.AvatarIKHint _hint;translator.Get(L, 2, out _hint); + UnityEngine.Vector3 _hintPosition;translator.Get(L, 3, out _hintPosition); + + gen_to_be_invoked.SetIKHintPosition( _hint, _hintPosition ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetIKHintPositionWeight(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.AvatarIKHint _hint;translator.Get(L, 2, out _hint); + + var gen_ret = gen_to_be_invoked.GetIKHintPositionWeight( _hint ); + LuaAPI.lua_pushnumber(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_SetIKHintPositionWeight(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.AvatarIKHint _hint;translator.Get(L, 2, out _hint); + float _value = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetIKHintPositionWeight( _hint, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLookAtPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector3 _lookAtPosition;translator.Get(L, 2, out _lookAtPosition); + + gen_to_be_invoked.SetLookAtPosition( _lookAtPosition ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLookAtWeight(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _weight = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.SetLookAtWeight( _weight ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _weight = (float)LuaAPI.lua_tonumber(L, 2); + float _bodyWeight = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetLookAtWeight( _weight, _bodyWeight ); + + + + return 0; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _weight = (float)LuaAPI.lua_tonumber(L, 2); + float _bodyWeight = (float)LuaAPI.lua_tonumber(L, 3); + float _headWeight = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.SetLookAtWeight( _weight, _bodyWeight, _headWeight ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + float _weight = (float)LuaAPI.lua_tonumber(L, 2); + float _bodyWeight = (float)LuaAPI.lua_tonumber(L, 3); + float _headWeight = (float)LuaAPI.lua_tonumber(L, 4); + float _eyesWeight = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.SetLookAtWeight( _weight, _bodyWeight, _headWeight, _eyesWeight ); + + + + return 0; + } + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + float _weight = (float)LuaAPI.lua_tonumber(L, 2); + float _bodyWeight = (float)LuaAPI.lua_tonumber(L, 3); + float _headWeight = (float)LuaAPI.lua_tonumber(L, 4); + float _eyesWeight = (float)LuaAPI.lua_tonumber(L, 5); + float _clampWeight = (float)LuaAPI.lua_tonumber(L, 6); + + gen_to_be_invoked.SetLookAtWeight( _weight, _bodyWeight, _headWeight, _eyesWeight, _clampWeight ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Animator.SetLookAtWeight!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetBoneLocalRotation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.HumanBodyBones _humanBoneId;translator.Get(L, 2, out _humanBoneId); + UnityEngine.Quaternion _rotation;translator.Get(L, 3, out _rotation); + + gen_to_be_invoked.SetBoneLocalRotation( _humanBoneId, _rotation ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetBehaviours(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + int _fullPathHash = LuaAPI.xlua_tointeger(L, 2); + int _layerIndex = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.GetBehaviours( _fullPathHash, _layerIndex ); + 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_GetLayerName(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + int _layerIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetLayerName( _layerIndex ); + 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 _m_GetLayerIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + string _layerName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetLayerIndex( _layerName ); + 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_GetLayerWeight(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + int _layerIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetLayerWeight( _layerIndex ); + LuaAPI.lua_pushnumber(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_SetLayerWeight(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + int _layerIndex = LuaAPI.xlua_tointeger(L, 2); + float _weight = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetLayerWeight( _layerIndex, _weight ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetCurrentAnimatorStateInfo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + int _layerIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetCurrentAnimatorStateInfo( _layerIndex ); + 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_GetNextAnimatorStateInfo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + int _layerIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetNextAnimatorStateInfo( _layerIndex ); + 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_GetAnimatorTransitionInfo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + int _layerIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetAnimatorTransitionInfo( _layerIndex ); + 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_GetCurrentAnimatorClipInfoCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + int _layerIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetCurrentAnimatorClipInfoCount( _layerIndex ); + 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_GetNextAnimatorClipInfoCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + int _layerIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetNextAnimatorClipInfoCount( _layerIndex ); + 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_GetCurrentAnimatorClipInfo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _layerIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetCurrentAnimatorClipInfo( _layerIndex ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _layerIndex = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _clips = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetCurrentAnimatorClipInfo( _layerIndex, _clips ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Animator.GetCurrentAnimatorClipInfo!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetNextAnimatorClipInfo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _layerIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetNextAnimatorClipInfo( _layerIndex ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _layerIndex = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _clips = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetNextAnimatorClipInfo( _layerIndex, _clips ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Animator.GetNextAnimatorClipInfo!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsInTransition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + int _layerIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.IsInTransition( _layerIndex ); + 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_GetParameter(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetParameter( _index ); + 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_MatchTarget(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 6&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Vector3 _matchPosition;translator.Get(L, 2, out _matchPosition); + UnityEngine.Quaternion _matchRotation;translator.Get(L, 3, out _matchRotation); + UnityEngine.AvatarTarget _targetBodyPart;translator.Get(L, 4, out _targetBodyPart); + UnityEngine.MatchTargetWeightMask _weightMask;translator.Get(L, 5, out _weightMask); + float _startNormalizedTime = (float)LuaAPI.lua_tonumber(L, 6); + + gen_to_be_invoked.MatchTarget( _matchPosition, _matchRotation, _targetBodyPart, _weightMask, _startNormalizedTime ); + + + + return 0; + } + if(gen_param_count == 7&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)) + { + UnityEngine.Vector3 _matchPosition;translator.Get(L, 2, out _matchPosition); + UnityEngine.Quaternion _matchRotation;translator.Get(L, 3, out _matchRotation); + UnityEngine.AvatarTarget _targetBodyPart;translator.Get(L, 4, out _targetBodyPart); + UnityEngine.MatchTargetWeightMask _weightMask;translator.Get(L, 5, out _weightMask); + float _startNormalizedTime = (float)LuaAPI.lua_tonumber(L, 6); + float _targetNormalizedTime = (float)LuaAPI.lua_tonumber(L, 7); + + gen_to_be_invoked.MatchTarget( _matchPosition, _matchRotation, _targetBodyPart, _weightMask, _startNormalizedTime, _targetNormalizedTime ); + + + + return 0; + } + if(gen_param_count == 8&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 8)) + { + UnityEngine.Vector3 _matchPosition;translator.Get(L, 2, out _matchPosition); + UnityEngine.Quaternion _matchRotation;translator.Get(L, 3, out _matchRotation); + UnityEngine.AvatarTarget _targetBodyPart;translator.Get(L, 4, out _targetBodyPart); + UnityEngine.MatchTargetWeightMask _weightMask;translator.Get(L, 5, out _weightMask); + float _startNormalizedTime = (float)LuaAPI.lua_tonumber(L, 6); + float _targetNormalizedTime = (float)LuaAPI.lua_tonumber(L, 7); + bool _completeMatch = LuaAPI.lua_toboolean(L, 8); + + gen_to_be_invoked.MatchTarget( _matchPosition, _matchRotation, _targetBodyPart, _weightMask, _startNormalizedTime, _targetNormalizedTime, _completeMatch ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Animator.MatchTarget!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_InterruptMatchTarget(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.InterruptMatchTarget( ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _completeMatch = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.InterruptMatchTarget( _completeMatch ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Animator.InterruptMatchTarget!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CrossFadeInFixedTime(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _stateHashName = LuaAPI.xlua_tointeger(L, 2); + float _fixedTransitionDuration = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.CrossFadeInFixedTime( _stateHashName, _fixedTransitionDuration ); + + + + return 0; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + int _stateHashName = LuaAPI.xlua_tointeger(L, 2); + float _fixedTransitionDuration = (float)LuaAPI.lua_tonumber(L, 3); + int _layer = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.CrossFadeInFixedTime( _stateHashName, _fixedTransitionDuration, _layer ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int _stateHashName = LuaAPI.xlua_tointeger(L, 2); + float _fixedTransitionDuration = (float)LuaAPI.lua_tonumber(L, 3); + int _layer = LuaAPI.xlua_tointeger(L, 4); + float _fixedTimeOffset = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.CrossFadeInFixedTime( _stateHashName, _fixedTransitionDuration, _layer, _fixedTimeOffset ); + + + + return 0; + } + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + int _stateHashName = LuaAPI.xlua_tointeger(L, 2); + float _fixedTransitionDuration = (float)LuaAPI.lua_tonumber(L, 3); + int _layer = LuaAPI.xlua_tointeger(L, 4); + float _fixedTimeOffset = (float)LuaAPI.lua_tonumber(L, 5); + float _normalizedTransitionTime = (float)LuaAPI.lua_tonumber(L, 6); + + gen_to_be_invoked.CrossFadeInFixedTime( _stateHashName, _fixedTransitionDuration, _layer, _fixedTimeOffset, _normalizedTransitionTime ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + string _stateName = LuaAPI.lua_tostring(L, 2); + float _fixedTransitionDuration = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.CrossFadeInFixedTime( _stateName, _fixedTransitionDuration ); + + + + return 0; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + string _stateName = LuaAPI.lua_tostring(L, 2); + float _fixedTransitionDuration = (float)LuaAPI.lua_tonumber(L, 3); + int _layer = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.CrossFadeInFixedTime( _stateName, _fixedTransitionDuration, _layer ); + + + + return 0; + } + if(gen_param_count == 5&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + string _stateName = LuaAPI.lua_tostring(L, 2); + float _fixedTransitionDuration = (float)LuaAPI.lua_tonumber(L, 3); + int _layer = LuaAPI.xlua_tointeger(L, 4); + float _fixedTimeOffset = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.CrossFadeInFixedTime( _stateName, _fixedTransitionDuration, _layer, _fixedTimeOffset ); + + + + return 0; + } + if(gen_param_count == 6&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + string _stateName = LuaAPI.lua_tostring(L, 2); + float _fixedTransitionDuration = (float)LuaAPI.lua_tonumber(L, 3); + int _layer = LuaAPI.xlua_tointeger(L, 4); + float _fixedTimeOffset = (float)LuaAPI.lua_tonumber(L, 5); + float _normalizedTransitionTime = (float)LuaAPI.lua_tonumber(L, 6); + + gen_to_be_invoked.CrossFadeInFixedTime( _stateName, _fixedTransitionDuration, _layer, _fixedTimeOffset, _normalizedTransitionTime ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Animator.CrossFadeInFixedTime!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_WriteDefaultValues(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.WriteDefaultValues( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CrossFade(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _stateHashName = LuaAPI.xlua_tointeger(L, 2); + float _normalizedTransitionDuration = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.CrossFade( _stateHashName, _normalizedTransitionDuration ); + + + + return 0; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + int _stateHashName = LuaAPI.xlua_tointeger(L, 2); + float _normalizedTransitionDuration = (float)LuaAPI.lua_tonumber(L, 3); + int _layer = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.CrossFade( _stateHashName, _normalizedTransitionDuration, _layer ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int _stateHashName = LuaAPI.xlua_tointeger(L, 2); + float _normalizedTransitionDuration = (float)LuaAPI.lua_tonumber(L, 3); + int _layer = LuaAPI.xlua_tointeger(L, 4); + float _normalizedTimeOffset = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.CrossFade( _stateHashName, _normalizedTransitionDuration, _layer, _normalizedTimeOffset ); + + + + return 0; + } + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + int _stateHashName = LuaAPI.xlua_tointeger(L, 2); + float _normalizedTransitionDuration = (float)LuaAPI.lua_tonumber(L, 3); + int _layer = LuaAPI.xlua_tointeger(L, 4); + float _normalizedTimeOffset = (float)LuaAPI.lua_tonumber(L, 5); + float _normalizedTransitionTime = (float)LuaAPI.lua_tonumber(L, 6); + + gen_to_be_invoked.CrossFade( _stateHashName, _normalizedTransitionDuration, _layer, _normalizedTimeOffset, _normalizedTransitionTime ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + string _stateName = LuaAPI.lua_tostring(L, 2); + float _normalizedTransitionDuration = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.CrossFade( _stateName, _normalizedTransitionDuration ); + + + + return 0; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + string _stateName = LuaAPI.lua_tostring(L, 2); + float _normalizedTransitionDuration = (float)LuaAPI.lua_tonumber(L, 3); + int _layer = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.CrossFade( _stateName, _normalizedTransitionDuration, _layer ); + + + + return 0; + } + if(gen_param_count == 5&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + string _stateName = LuaAPI.lua_tostring(L, 2); + float _normalizedTransitionDuration = (float)LuaAPI.lua_tonumber(L, 3); + int _layer = LuaAPI.xlua_tointeger(L, 4); + float _normalizedTimeOffset = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.CrossFade( _stateName, _normalizedTransitionDuration, _layer, _normalizedTimeOffset ); + + + + return 0; + } + if(gen_param_count == 6&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + string _stateName = LuaAPI.lua_tostring(L, 2); + float _normalizedTransitionDuration = (float)LuaAPI.lua_tonumber(L, 3); + int _layer = LuaAPI.xlua_tointeger(L, 4); + float _normalizedTimeOffset = (float)LuaAPI.lua_tonumber(L, 5); + float _normalizedTransitionTime = (float)LuaAPI.lua_tonumber(L, 6); + + gen_to_be_invoked.CrossFade( _stateName, _normalizedTransitionDuration, _layer, _normalizedTimeOffset, _normalizedTransitionTime ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Animator.CrossFade!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PlayInFixedTime(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _stateNameHash = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.PlayInFixedTime( _stateNameHash ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _stateNameHash = LuaAPI.xlua_tointeger(L, 2); + int _layer = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.PlayInFixedTime( _stateNameHash, _layer ); + + + + return 0; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + int _stateNameHash = LuaAPI.xlua_tointeger(L, 2); + int _layer = LuaAPI.xlua_tointeger(L, 3); + float _fixedTime = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.PlayInFixedTime( _stateNameHash, _layer, _fixedTime ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _stateName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.PlayInFixedTime( _stateName ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + string _stateName = LuaAPI.lua_tostring(L, 2); + int _layer = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.PlayInFixedTime( _stateName, _layer ); + + + + return 0; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + string _stateName = LuaAPI.lua_tostring(L, 2); + int _layer = LuaAPI.xlua_tointeger(L, 3); + float _fixedTime = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.PlayInFixedTime( _stateName, _layer, _fixedTime ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Animator.PlayInFixedTime!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Play(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _stateNameHash = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.Play( _stateNameHash ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _stateNameHash = LuaAPI.xlua_tointeger(L, 2); + int _layer = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.Play( _stateNameHash, _layer ); + + + + return 0; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + int _stateNameHash = LuaAPI.xlua_tointeger(L, 2); + int _layer = LuaAPI.xlua_tointeger(L, 3); + float _normalizedTime = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.Play( _stateNameHash, _layer, _normalizedTime ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _stateName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.Play( _stateName ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + string _stateName = LuaAPI.lua_tostring(L, 2); + int _layer = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.Play( _stateName, _layer ); + + + + return 0; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + string _stateName = LuaAPI.lua_tostring(L, 2); + int _layer = LuaAPI.xlua_tointeger(L, 3); + float _normalizedTime = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.Play( _stateName, _layer, _normalizedTime ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Animator.Play!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTarget(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.AvatarTarget _targetIndex;translator.Get(L, 2, out _targetIndex); + float _targetNormalizedTime = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetTarget( _targetIndex, _targetNormalizedTime ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetBoneTransform(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.HumanBodyBones _humanBoneId;translator.Get(L, 2, out _humanBoneId); + + var gen_ret = gen_to_be_invoked.GetBoneTransform( _humanBoneId ); + 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_StartPlayback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.StartPlayback( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_StopPlayback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.StopPlayback( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_StartRecording(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + int _frameCount = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.StartRecording( _frameCount ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_StopRecording(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.StopRecording( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasState(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + int _layerIndex = LuaAPI.xlua_tointeger(L, 2); + int _stateID = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.HasState( _layerIndex, _stateID ); + 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_StringToHash_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _name = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.Animator.StringToHash( _name ); + 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_Update(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + float _deltaTime = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.Update( _deltaTime ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Rebind(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Rebind( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ApplyBuiltinRootMotion(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ApplyBuiltinRootMotion( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isOptimizable(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isOptimizable); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isHuman(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isHuman); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_hasRootMotion(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hasRootMotion); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_humanScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.humanScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isInitialized(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isInitialized); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_deltaPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.deltaPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_deltaRotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineQuaternion(L, gen_to_be_invoked.deltaRotation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_velocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.velocity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_angularVelocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.angularVelocity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rootPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.rootPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rootRotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineQuaternion(L, gen_to_be_invoked.rootRotation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_applyRootMotion(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.applyRootMotion); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_updateMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.updateMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_hasTransformHierarchy(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hasTransformHierarchy); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_gravityWeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.gravityWeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bodyPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.bodyPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bodyRotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineQuaternion(L, gen_to_be_invoked.bodyRotation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_stabilizeFeet(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.stabilizeFeet); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_layerCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.layerCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_parameters(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.parameters); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_parameterCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.parameterCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_feetPivotActive(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.feetPivotActive); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_pivotWeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.pivotWeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_pivotPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.pivotPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isMatchingTarget(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isMatchingTarget); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_speed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.speed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_targetPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.targetPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_targetRotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineQuaternion(L, gen_to_be_invoked.targetRotation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cullingMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineAnimatorCullingMode(L, gen_to_be_invoked.cullingMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_playbackTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.playbackTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_recorderStartTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.recorderStartTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_recorderStopTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.recorderStopTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_recorderMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.recorderMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_runtimeAnimatorController(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.runtimeAnimatorController); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_hasBoundPlayables(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hasBoundPlayables); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_avatar(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.avatar); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_playableGraph(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.playableGraph); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_layersAffectMassCenter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.layersAffectMassCenter); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_leftFeetBottomHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.leftFeetBottomHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rightFeetBottomHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.rightFeetBottomHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_logWarnings(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.logWarnings); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fireEvents(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.fireEvents); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_keepAnimatorStateOnDisable(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.keepAnimatorStateOnDisable); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_writeDefaultValuesOnDisable(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.writeDefaultValuesOnDisable); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_rootPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.rootPosition = 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_rootRotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + UnityEngine.Quaternion gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.rootRotation = 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_applyRootMotion(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.applyRootMotion = 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_updateMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + UnityEngine.AnimatorUpdateMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.updateMode = 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_bodyPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.bodyPosition = 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_bodyRotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + UnityEngine.Quaternion gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.bodyRotation = 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_stabilizeFeet(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.stabilizeFeet = 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_feetPivotActive(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.feetPivotActive = (float)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_speed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.speed = (float)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_cullingMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + UnityEngine.AnimatorCullingMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.cullingMode = 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_playbackTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.playbackTime = (float)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_recorderStartTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.recorderStartTime = (float)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_recorderStopTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.recorderStopTime = (float)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_runtimeAnimatorController(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.runtimeAnimatorController = (UnityEngine.RuntimeAnimatorController)translator.GetObject(L, 2, typeof(UnityEngine.RuntimeAnimatorController)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_avatar(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.avatar = (UnityEngine.Avatar)translator.GetObject(L, 2, typeof(UnityEngine.Avatar)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_layersAffectMassCenter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.layersAffectMassCenter = 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_logWarnings(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.logWarnings = 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_fireEvents(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.fireEvents = 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_keepAnimatorStateOnDisable(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.keepAnimatorStateOnDisable = 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_writeDefaultValuesOnDisable(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Animator gen_to_be_invoked = (UnityEngine.Animator)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.writeDefaultValuesOnDisable = LuaAPI.lua_toboolean(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ApplicationWrap.cs b/Assets/XLua/Gen/UnityEngine_ApplicationWrap.cs new file mode 100644 index 000000000..a335ede1e --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ApplicationWrap.cs @@ -0,0 +1,1162 @@ +#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 UnityEngineApplicationWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Application); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 23, 30, 3); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Quit", _m_Quit_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Unload", _m_Unload_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CanStreamedLevelBeLoaded", _m_CanStreamedLevelBeLoaded_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IsPlaying", _m_IsPlaying_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetBuildTags", _m_GetBuildTags_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetBuildTags", _m_SetBuildTags_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "HasProLicense", _m_HasProLicense_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RequestAdvertisingIdentifierAsync", _m_RequestAdvertisingIdentifierAsync_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "OpenURL", _m_OpenURL_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetStackTraceLogType", _m_GetStackTraceLogType_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetStackTraceLogType", _m_SetStackTraceLogType_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RequestUserAuthorization", _m_RequestUserAuthorization_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "HasUserAuthorization", _m_HasUserAuthorization_xlua_st_); + + Utils.RegisterFunc(L, Utils.CLS_IDX, "lowMemory", _e_lowMemory); + Utils.RegisterFunc(L, Utils.CLS_IDX, "logMessageReceived", _e_logMessageReceived); + Utils.RegisterFunc(L, Utils.CLS_IDX, "logMessageReceivedThreaded", _e_logMessageReceivedThreaded); + Utils.RegisterFunc(L, Utils.CLS_IDX, "onBeforeRender", _e_onBeforeRender); + Utils.RegisterFunc(L, Utils.CLS_IDX, "focusChanged", _e_focusChanged); + Utils.RegisterFunc(L, Utils.CLS_IDX, "deepLinkActivated", _e_deepLinkActivated); + Utils.RegisterFunc(L, Utils.CLS_IDX, "wantsToQuit", _e_wantsToQuit); + Utils.RegisterFunc(L, Utils.CLS_IDX, "quitting", _e_quitting); + Utils.RegisterFunc(L, Utils.CLS_IDX, "unloading", _e_unloading); + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "isPlaying", _g_get_isPlaying); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "isFocused", _g_get_isFocused); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "buildGUID", _g_get_buildGUID); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "runInBackground", _g_get_runInBackground); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "isBatchMode", _g_get_isBatchMode); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "dataPath", _g_get_dataPath); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "streamingAssetsPath", _g_get_streamingAssetsPath); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "persistentDataPath", _g_get_persistentDataPath); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "temporaryCachePath", _g_get_temporaryCachePath); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "absoluteURL", _g_get_absoluteURL); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "unityVersion", _g_get_unityVersion); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "version", _g_get_version); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "installerName", _g_get_installerName); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "identifier", _g_get_identifier); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "installMode", _g_get_installMode); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "sandboxType", _g_get_sandboxType); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "productName", _g_get_productName); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "companyName", _g_get_companyName); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "cloudProjectId", _g_get_cloudProjectId); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "targetFrameRate", _g_get_targetFrameRate); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "consoleLogPath", _g_get_consoleLogPath); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "backgroundLoadingPriority", _g_get_backgroundLoadingPriority); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "genuine", _g_get_genuine); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "genuineCheckAvailable", _g_get_genuineCheckAvailable); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "platform", _g_get_platform); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "isMobilePlatform", _g_get_isMobilePlatform); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "isConsolePlatform", _g_get_isConsolePlatform); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "systemLanguage", _g_get_systemLanguage); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "internetReachability", _g_get_internetReachability); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "isEditor", _g_get_isEditor); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "runInBackground", _s_set_runInBackground); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "targetFrameRate", _s_set_targetFrameRate); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "backgroundLoadingPriority", _s_set_backgroundLoadingPriority); + + + 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 UnityEngine.Application(); + 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 UnityEngine.Application constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Quit_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 0) + { + + UnityEngine.Application.Quit( ); + + + + return 0; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _exitCode = LuaAPI.xlua_tointeger(L, 1); + + UnityEngine.Application.Quit( _exitCode ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Application.Quit!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Unload_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + UnityEngine.Application.Unload( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CanStreamedLevelBeLoaded_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _levelIndex = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = UnityEngine.Application.CanStreamedLevelBeLoaded( _levelIndex ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _levelName = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.Application.CanStreamedLevelBeLoaded( _levelName ); + LuaAPI.lua_pushboolean(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 UnityEngine.Application.CanStreamedLevelBeLoaded!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsPlaying_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Object _obj = (UnityEngine.Object)translator.GetObject(L, 1, typeof(UnityEngine.Object)); + + var gen_ret = UnityEngine.Application.IsPlaying( _obj ); + 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_GetBuildTags_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = UnityEngine.Application.GetBuildTags( ); + 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_SetBuildTags_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string[] _buildTags = (string[])translator.GetObject(L, 1, typeof(string[])); + + UnityEngine.Application.SetBuildTags( _buildTags ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasProLicense_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = UnityEngine.Application.HasProLicense( ); + 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_RequestAdvertisingIdentifierAsync_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Application.AdvertisingIdentifierCallback _delegateMethod = translator.GetDelegate(L, 1); + + var gen_ret = UnityEngine.Application.RequestAdvertisingIdentifierAsync( _delegateMethod ); + 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_OpenURL_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _url = LuaAPI.lua_tostring(L, 1); + + UnityEngine.Application.OpenURL( _url ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetStackTraceLogType_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.LogType _logType;translator.Get(L, 1, out _logType); + + var gen_ret = UnityEngine.Application.GetStackTraceLogType( _logType ); + 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_SetStackTraceLogType_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.LogType _logType;translator.Get(L, 1, out _logType); + UnityEngine.StackTraceLogType _stackTraceType;translator.Get(L, 2, out _stackTraceType); + + UnityEngine.Application.SetStackTraceLogType( _logType, _stackTraceType ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RequestUserAuthorization_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.UserAuthorization _mode;translator.Get(L, 1, out _mode); + + var gen_ret = UnityEngine.Application.RequestUserAuthorization( _mode ); + 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_HasUserAuthorization_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.UserAuthorization _mode;translator.Get(L, 1, out _mode); + + var gen_ret = UnityEngine.Application.HasUserAuthorization( _mode ); + 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 _g_get_isPlaying(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Application.isPlaying); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isFocused(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Application.isFocused); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_buildGUID(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, UnityEngine.Application.buildGUID); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_runInBackground(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Application.runInBackground); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isBatchMode(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Application.isBatchMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_dataPath(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, UnityEngine.Application.dataPath); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_streamingAssetsPath(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, UnityEngine.Application.streamingAssetsPath); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_persistentDataPath(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, UnityEngine.Application.persistentDataPath); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_temporaryCachePath(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, UnityEngine.Application.temporaryCachePath); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_absoluteURL(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, UnityEngine.Application.absoluteURL); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_unityVersion(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, UnityEngine.Application.unityVersion); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_version(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, UnityEngine.Application.version); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_installerName(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, UnityEngine.Application.installerName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_identifier(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, UnityEngine.Application.identifier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_installMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Application.installMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sandboxType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Application.sandboxType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_productName(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, UnityEngine.Application.productName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_companyName(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, UnityEngine.Application.companyName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cloudProjectId(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, UnityEngine.Application.cloudProjectId); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_targetFrameRate(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.Application.targetFrameRate); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_consoleLogPath(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, UnityEngine.Application.consoleLogPath); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_backgroundLoadingPriority(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Application.backgroundLoadingPriority); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_genuine(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Application.genuine); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_genuineCheckAvailable(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Application.genuineCheckAvailable); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_platform(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineRuntimePlatform(L, UnityEngine.Application.platform); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isMobilePlatform(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Application.isMobilePlatform); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isConsolePlatform(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Application.isConsolePlatform); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_systemLanguage(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineSystemLanguage(L, UnityEngine.Application.systemLanguage); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_internetReachability(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineNetworkReachability(L, UnityEngine.Application.internetReachability); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isEditor(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Application.isEditor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_runInBackground(RealStatePtr L) + { + try { + + UnityEngine.Application.runInBackground = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_targetFrameRate(RealStatePtr L) + { + try { + + UnityEngine.Application.targetFrameRate = LuaAPI.xlua_tointeger(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_backgroundLoadingPriority(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + UnityEngine.ThreadPriority gen_value;translator.Get(L, 1, out gen_value); + UnityEngine.Application.backgroundLoadingPriority = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_lowMemory(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + UnityEngine.Application.LowMemoryCallback gen_delegate = translator.GetDelegate(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need UnityEngine.Application.LowMemoryCallback!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + UnityEngine.Application.lowMemory += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + UnityEngine.Application.lowMemory -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Application.lowMemory!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_logMessageReceived(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + UnityEngine.Application.LogCallback gen_delegate = translator.GetDelegate(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need UnityEngine.Application.LogCallback!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + UnityEngine.Application.logMessageReceived += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + UnityEngine.Application.logMessageReceived -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Application.logMessageReceived!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_logMessageReceivedThreaded(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + UnityEngine.Application.LogCallback gen_delegate = translator.GetDelegate(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need UnityEngine.Application.LogCallback!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + UnityEngine.Application.logMessageReceivedThreaded += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + UnityEngine.Application.logMessageReceivedThreaded -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Application.logMessageReceivedThreaded!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_onBeforeRender(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + UnityEngine.Events.UnityAction gen_delegate = translator.GetDelegate(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need UnityEngine.Events.UnityAction!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + UnityEngine.Application.onBeforeRender += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + UnityEngine.Application.onBeforeRender -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Application.onBeforeRender!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_focusChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + UnityEngine.Application.focusChanged += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + UnityEngine.Application.focusChanged -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Application.focusChanged!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_deepLinkActivated(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + UnityEngine.Application.deepLinkActivated += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + UnityEngine.Application.deepLinkActivated -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Application.deepLinkActivated!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_wantsToQuit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Func gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Func!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + UnityEngine.Application.wantsToQuit += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + UnityEngine.Application.wantsToQuit -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Application.wantsToQuit!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_quitting(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + UnityEngine.Application.quitting += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + UnityEngine.Application.quitting -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Application.quitting!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_unloading(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + UnityEngine.Application.unloading += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + UnityEngine.Application.unloading -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Application.unloading!"); + } + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_AssetBundleRequestWrap.cs b/Assets/XLua/Gen/UnityEngine_AssetBundleRequestWrap.cs new file mode 100644 index 000000000..f06619bf1 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_AssetBundleRequestWrap.cs @@ -0,0 +1,114 @@ +#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 UnityEngineAssetBundleRequestWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.AssetBundleRequest); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 0); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "asset", _g_get_asset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "allAssets", _g_get_allAssets); + + + + 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 UnityEngine.AssetBundleRequest(); + 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 UnityEngine.AssetBundleRequest constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_asset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AssetBundleRequest gen_to_be_invoked = (UnityEngine.AssetBundleRequest)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.asset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_allAssets(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AssetBundleRequest gen_to_be_invoked = (UnityEngine.AssetBundleRequest)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.allAssets); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_AssetBundleWrap.cs b/Assets/XLua/Gen/UnityEngine_AssetBundleWrap.cs new file mode 100644 index 000000000..0db50303f --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_AssetBundleWrap.cs @@ -0,0 +1,959 @@ +#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 UnityEngineAssetBundleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.AssetBundle); + Utils.BeginObjectRegister(type, L, translator, 0, 11, 1, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Contains", _m_Contains); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadAsset", _m_LoadAsset); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadAssetAsync", _m_LoadAssetAsync); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadAssetWithSubAssets", _m_LoadAssetWithSubAssets); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadAssetWithSubAssetsAsync", _m_LoadAssetWithSubAssetsAsync); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadAllAssets", _m_LoadAllAssets); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadAllAssetsAsync", _m_LoadAllAssetsAsync); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Unload", _m_Unload); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnloadAsync", _m_UnloadAsync); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAllAssetNames", _m_GetAllAssetNames); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAllScenePaths", _m_GetAllScenePaths); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isStreamedSceneAssetBundle", _g_get_isStreamedSceneAssetBundle); + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 10, 1, 1); + Utils.RegisterFunc(L, Utils.CLS_IDX, "UnloadAllAssetBundles", _m_UnloadAllAssetBundles_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetAllLoadedAssetBundles", _m_GetAllLoadedAssetBundles_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadFromFileAsync", _m_LoadFromFileAsync_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadFromFile", _m_LoadFromFile_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadFromMemoryAsync", _m_LoadFromMemoryAsync_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadFromMemory", _m_LoadFromMemory_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadFromStreamAsync", _m_LoadFromStreamAsync_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadFromStream", _m_LoadFromStream_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RecompressAssetBundleAsync", _m_RecompressAssetBundleAsync_xlua_st_); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "memoryBudgetKB", _g_get_memoryBudgetKB); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "memoryBudgetKB", _s_set_memoryBudgetKB); + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "UnityEngine.AssetBundle does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UnloadAllAssetBundles_xlua_st_(RealStatePtr L) + { + try { + + + + + { + bool _unloadAllObjects = LuaAPI.lua_toboolean(L, 1); + + UnityEngine.AssetBundle.UnloadAllAssetBundles( _unloadAllObjects ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetAllLoadedAssetBundles_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = UnityEngine.AssetBundle.GetAllLoadedAssetBundles( ); + 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_LoadFromFileAsync_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 _path = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.AssetBundle.LoadFromFileAsync( _path ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + string _path = LuaAPI.lua_tostring(L, 1); + uint _crc = LuaAPI.xlua_touint(L, 2); + + var gen_ret = UnityEngine.AssetBundle.LoadFromFileAsync( _path, _crc ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) || LuaAPI.lua_isuint64(L, 3))) + { + string _path = LuaAPI.lua_tostring(L, 1); + uint _crc = LuaAPI.xlua_touint(L, 2); + ulong _offset = LuaAPI.lua_touint64(L, 3); + + var gen_ret = UnityEngine.AssetBundle.LoadFromFileAsync( _path, _crc, _offset ); + 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 UnityEngine.AssetBundle.LoadFromFileAsync!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadFromFile_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 _path = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.AssetBundle.LoadFromFile( _path ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + string _path = LuaAPI.lua_tostring(L, 1); + uint _crc = LuaAPI.xlua_touint(L, 2); + + var gen_ret = UnityEngine.AssetBundle.LoadFromFile( _path, _crc ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) || LuaAPI.lua_isuint64(L, 3))) + { + string _path = LuaAPI.lua_tostring(L, 1); + uint _crc = LuaAPI.xlua_touint(L, 2); + ulong _offset = LuaAPI.lua_touint64(L, 3); + + var gen_ret = UnityEngine.AssetBundle.LoadFromFile( _path, _crc, _offset ); + 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 UnityEngine.AssetBundle.LoadFromFile!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadFromMemoryAsync_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)) + { + byte[] _binary = LuaAPI.lua_tobytes(L, 1); + + var gen_ret = UnityEngine.AssetBundle.LoadFromMemoryAsync( _binary ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + byte[] _binary = LuaAPI.lua_tobytes(L, 1); + uint _crc = LuaAPI.xlua_touint(L, 2); + + var gen_ret = UnityEngine.AssetBundle.LoadFromMemoryAsync( _binary, _crc ); + 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 UnityEngine.AssetBundle.LoadFromMemoryAsync!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadFromMemory_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)) + { + byte[] _binary = LuaAPI.lua_tobytes(L, 1); + + var gen_ret = UnityEngine.AssetBundle.LoadFromMemory( _binary ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + byte[] _binary = LuaAPI.lua_tobytes(L, 1); + uint _crc = LuaAPI.xlua_touint(L, 2); + + var gen_ret = UnityEngine.AssetBundle.LoadFromMemory( _binary, _crc ); + 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 UnityEngine.AssetBundle.LoadFromMemory!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadFromStreamAsync_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + System.IO.Stream _stream = (System.IO.Stream)translator.GetObject(L, 1, typeof(System.IO.Stream)); + + var gen_ret = UnityEngine.AssetBundle.LoadFromStreamAsync( _stream ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + System.IO.Stream _stream = (System.IO.Stream)translator.GetObject(L, 1, typeof(System.IO.Stream)); + uint _crc = LuaAPI.xlua_touint(L, 2); + + var gen_ret = UnityEngine.AssetBundle.LoadFromStreamAsync( _stream, _crc ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + System.IO.Stream _stream = (System.IO.Stream)translator.GetObject(L, 1, typeof(System.IO.Stream)); + uint _crc = LuaAPI.xlua_touint(L, 2); + uint _managedReadBufferSize = LuaAPI.xlua_touint(L, 3); + + var gen_ret = UnityEngine.AssetBundle.LoadFromStreamAsync( _stream, _crc, _managedReadBufferSize ); + 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 UnityEngine.AssetBundle.LoadFromStreamAsync!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadFromStream_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + System.IO.Stream _stream = (System.IO.Stream)translator.GetObject(L, 1, typeof(System.IO.Stream)); + + var gen_ret = UnityEngine.AssetBundle.LoadFromStream( _stream ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + System.IO.Stream _stream = (System.IO.Stream)translator.GetObject(L, 1, typeof(System.IO.Stream)); + uint _crc = LuaAPI.xlua_touint(L, 2); + + var gen_ret = UnityEngine.AssetBundle.LoadFromStream( _stream, _crc ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + System.IO.Stream _stream = (System.IO.Stream)translator.GetObject(L, 1, typeof(System.IO.Stream)); + uint _crc = LuaAPI.xlua_touint(L, 2); + uint _managedReadBufferSize = LuaAPI.xlua_touint(L, 3); + + var gen_ret = UnityEngine.AssetBundle.LoadFromStream( _stream, _crc, _managedReadBufferSize ); + 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 UnityEngine.AssetBundle.LoadFromStream!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Contains(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AssetBundle gen_to_be_invoked = (UnityEngine.AssetBundle)translator.FastGetCSObj(L, 1); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.Contains( _name ); + 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_LoadAsset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AssetBundle gen_to_be_invoked = (UnityEngine.AssetBundle)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.LoadAsset( _name ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + System.Type _type = (System.Type)translator.GetObject(L, 3, typeof(System.Type)); + + var gen_ret = gen_to_be_invoked.LoadAsset( _name, _type ); + 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 UnityEngine.AssetBundle.LoadAsset!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadAssetAsync(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AssetBundle gen_to_be_invoked = (UnityEngine.AssetBundle)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.LoadAssetAsync( _name ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + System.Type _type = (System.Type)translator.GetObject(L, 3, typeof(System.Type)); + + var gen_ret = gen_to_be_invoked.LoadAssetAsync( _name, _type ); + 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 UnityEngine.AssetBundle.LoadAssetAsync!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadAssetWithSubAssets(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AssetBundle gen_to_be_invoked = (UnityEngine.AssetBundle)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.LoadAssetWithSubAssets( _name ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + System.Type _type = (System.Type)translator.GetObject(L, 3, typeof(System.Type)); + + var gen_ret = gen_to_be_invoked.LoadAssetWithSubAssets( _name, _type ); + 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 UnityEngine.AssetBundle.LoadAssetWithSubAssets!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadAssetWithSubAssetsAsync(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AssetBundle gen_to_be_invoked = (UnityEngine.AssetBundle)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.LoadAssetWithSubAssetsAsync( _name ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + System.Type _type = (System.Type)translator.GetObject(L, 3, typeof(System.Type)); + + var gen_ret = gen_to_be_invoked.LoadAssetWithSubAssetsAsync( _name, _type ); + 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 UnityEngine.AssetBundle.LoadAssetWithSubAssetsAsync!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadAllAssets(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AssetBundle gen_to_be_invoked = (UnityEngine.AssetBundle)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.LoadAllAssets( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.Type _type = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + + var gen_ret = gen_to_be_invoked.LoadAllAssets( _type ); + 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 UnityEngine.AssetBundle.LoadAllAssets!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadAllAssetsAsync(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AssetBundle gen_to_be_invoked = (UnityEngine.AssetBundle)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.LoadAllAssetsAsync( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.Type _type = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + + var gen_ret = gen_to_be_invoked.LoadAllAssetsAsync( _type ); + 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 UnityEngine.AssetBundle.LoadAllAssetsAsync!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Unload(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AssetBundle gen_to_be_invoked = (UnityEngine.AssetBundle)translator.FastGetCSObj(L, 1); + + + + { + bool _unloadAllLoadedObjects = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.Unload( _unloadAllLoadedObjects ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UnloadAsync(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AssetBundle gen_to_be_invoked = (UnityEngine.AssetBundle)translator.FastGetCSObj(L, 1); + + + + { + bool _unloadAllLoadedObjects = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.UnloadAsync( _unloadAllLoadedObjects ); + 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_GetAllAssetNames(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AssetBundle gen_to_be_invoked = (UnityEngine.AssetBundle)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetAllAssetNames( ); + 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_GetAllScenePaths(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AssetBundle gen_to_be_invoked = (UnityEngine.AssetBundle)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetAllScenePaths( ); + 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_RecompressAssetBundleAsync_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 5&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + string _inputPath = LuaAPI.lua_tostring(L, 1); + string _outputPath = LuaAPI.lua_tostring(L, 2); + UnityEngine.BuildCompression _method;translator.Get(L, 3, out _method); + uint _expectedCRC = LuaAPI.xlua_touint(L, 4); + UnityEngine.ThreadPriority _priority;translator.Get(L, 5, out _priority); + + var gen_ret = UnityEngine.AssetBundle.RecompressAssetBundleAsync( _inputPath, _outputPath, _method, _expectedCRC, _priority ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + string _inputPath = LuaAPI.lua_tostring(L, 1); + string _outputPath = LuaAPI.lua_tostring(L, 2); + UnityEngine.BuildCompression _method;translator.Get(L, 3, out _method); + uint _expectedCRC = LuaAPI.xlua_touint(L, 4); + + var gen_ret = UnityEngine.AssetBundle.RecompressAssetBundleAsync( _inputPath, _outputPath, _method, _expectedCRC ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _inputPath = LuaAPI.lua_tostring(L, 1); + string _outputPath = LuaAPI.lua_tostring(L, 2); + UnityEngine.BuildCompression _method;translator.Get(L, 3, out _method); + + var gen_ret = UnityEngine.AssetBundle.RecompressAssetBundleAsync( _inputPath, _outputPath, _method ); + 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 UnityEngine.AssetBundle.RecompressAssetBundleAsync!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isStreamedSceneAssetBundle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AssetBundle gen_to_be_invoked = (UnityEngine.AssetBundle)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isStreamedSceneAssetBundle); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_memoryBudgetKB(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushuint(L, UnityEngine.AssetBundle.memoryBudgetKB); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_memoryBudgetKB(RealStatePtr L) + { + try { + + UnityEngine.AssetBundle.memoryBudgetKB = LuaAPI.xlua_touint(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_AsyncOperationWrap.cs b/Assets/XLua/Gen/UnityEngine_AsyncOperationWrap.cs new file mode 100644 index 000000000..12ec322fa --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_AsyncOperationWrap.cs @@ -0,0 +1,211 @@ +#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 UnityEngineAsyncOperationWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.AsyncOperation); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 4, 2); + + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "completed", _e_completed); + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isDone", _g_get_isDone); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "progress", _g_get_progress); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "priority", _g_get_priority); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "allowSceneActivation", _g_get_allowSceneActivation); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "priority", _s_set_priority); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "allowSceneActivation", _s_set_allowSceneActivation); + + + 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 UnityEngine.AsyncOperation(); + 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 UnityEngine.AsyncOperation constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isDone(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AsyncOperation gen_to_be_invoked = (UnityEngine.AsyncOperation)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isDone); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_progress(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AsyncOperation gen_to_be_invoked = (UnityEngine.AsyncOperation)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.progress); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_priority(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AsyncOperation gen_to_be_invoked = (UnityEngine.AsyncOperation)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.priority); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_allowSceneActivation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AsyncOperation gen_to_be_invoked = (UnityEngine.AsyncOperation)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.allowSceneActivation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_priority(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AsyncOperation gen_to_be_invoked = (UnityEngine.AsyncOperation)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.priority = 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_allowSceneActivation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AsyncOperation gen_to_be_invoked = (UnityEngine.AsyncOperation)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.allowSceneActivation = 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 _e_completed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + UnityEngine.AsyncOperation gen_to_be_invoked = (UnityEngine.AsyncOperation)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.completed += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.completed -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.AsyncOperation.completed!"); + return 0; + } + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_AudioClipWrap.cs b/Assets/XLua/Gen/UnityEngine_AudioClipWrap.cs new file mode 100644 index 000000000..e303a38b9 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_AudioClipWrap.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 UnityEngineAudioClipWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.AudioClip); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 9, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadAudioData", _m_LoadAudioData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnloadAudioData", _m_UnloadAudioData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetData", _m_GetData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetData", _m_SetData); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "length", _g_get_length); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "samples", _g_get_samples); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "channels", _g_get_channels); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "frequency", _g_get_frequency); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "loadType", _g_get_loadType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preloadAudioData", _g_get_preloadAudioData); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ambisonic", _g_get_ambisonic); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "loadInBackground", _g_get_loadInBackground); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "loadState", _g_get_loadState); + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Create", _m_Create_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "UnityEngine.AudioClip does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadAudioData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AudioClip gen_to_be_invoked = (UnityEngine.AudioClip)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.LoadAudioData( ); + 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_UnloadAudioData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AudioClip gen_to_be_invoked = (UnityEngine.AudioClip)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.UnloadAudioData( ); + 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_GetData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AudioClip gen_to_be_invoked = (UnityEngine.AudioClip)translator.FastGetCSObj(L, 1); + + + + { + float[] _data = (float[])translator.GetObject(L, 2, typeof(float[])); + int _offsetSamples = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.GetData( _data, _offsetSamples ); + 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_SetData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AudioClip gen_to_be_invoked = (UnityEngine.AudioClip)translator.FastGetCSObj(L, 1); + + + + { + float[] _data = (float[])translator.GetObject(L, 2, typeof(float[])); + int _offsetSamples = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.SetData( _data, _offsetSamples ); + 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_Create_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 5&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)) + { + string _name = LuaAPI.lua_tostring(L, 1); + int _lengthSamples = LuaAPI.xlua_tointeger(L, 2); + int _channels = LuaAPI.xlua_tointeger(L, 3); + int _frequency = LuaAPI.xlua_tointeger(L, 4); + bool _stream = LuaAPI.lua_toboolean(L, 5); + + var gen_ret = UnityEngine.AudioClip.Create( _name, _lengthSamples, _channels, _frequency, _stream ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)) + { + string _name = LuaAPI.lua_tostring(L, 1); + int _lengthSamples = LuaAPI.xlua_tointeger(L, 2); + int _channels = LuaAPI.xlua_tointeger(L, 3); + int _frequency = LuaAPI.xlua_tointeger(L, 4); + bool _stream = LuaAPI.lua_toboolean(L, 5); + UnityEngine.AudioClip.PCMReaderCallback _pcmreadercallback = translator.GetDelegate(L, 6); + + var gen_ret = UnityEngine.AudioClip.Create( _name, _lengthSamples, _channels, _frequency, _stream, _pcmreadercallback ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 7&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& translator.Assignable(L, 7)) + { + string _name = LuaAPI.lua_tostring(L, 1); + int _lengthSamples = LuaAPI.xlua_tointeger(L, 2); + int _channels = LuaAPI.xlua_tointeger(L, 3); + int _frequency = LuaAPI.xlua_tointeger(L, 4); + bool _stream = LuaAPI.lua_toboolean(L, 5); + UnityEngine.AudioClip.PCMReaderCallback _pcmreadercallback = translator.GetDelegate(L, 6); + UnityEngine.AudioClip.PCMSetPositionCallback _pcmsetpositioncallback = translator.GetDelegate(L, 7); + + var gen_ret = UnityEngine.AudioClip.Create( _name, _lengthSamples, _channels, _frequency, _stream, _pcmreadercallback, _pcmsetpositioncallback ); + 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 UnityEngine.AudioClip.Create!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_length(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioClip gen_to_be_invoked = (UnityEngine.AudioClip)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.length); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_samples(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioClip gen_to_be_invoked = (UnityEngine.AudioClip)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.samples); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_channels(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioClip gen_to_be_invoked = (UnityEngine.AudioClip)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.channels); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_frequency(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioClip gen_to_be_invoked = (UnityEngine.AudioClip)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.frequency); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_loadType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioClip gen_to_be_invoked = (UnityEngine.AudioClip)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.loadType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preloadAudioData(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioClip gen_to_be_invoked = (UnityEngine.AudioClip)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.preloadAudioData); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ambisonic(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioClip gen_to_be_invoked = (UnityEngine.AudioClip)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.ambisonic); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_loadInBackground(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioClip gen_to_be_invoked = (UnityEngine.AudioClip)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.loadInBackground); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_loadState(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioClip gen_to_be_invoked = (UnityEngine.AudioClip)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.loadState); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_AudioSourceWrap.cs b/Assets/XLua/Gen/UnityEngine_AudioSourceWrap.cs new file mode 100644 index 000000000..679a7e59e --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_AudioSourceWrap.cs @@ -0,0 +1,1563 @@ +#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; +using DG.Tweening; + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class UnityEngineAudioSourceWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.AudioSource); + Utils.BeginObjectRegister(type, L, translator, 0, 19, 28, 26); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Play", _m_Play); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PlayDelayed", _m_PlayDelayed); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PlayScheduled", _m_PlayScheduled); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PlayOneShot", _m_PlayOneShot); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetScheduledStartTime", _m_SetScheduledStartTime); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetScheduledEndTime", _m_SetScheduledEndTime); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Stop", _m_Stop); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Pause", _m_Pause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnPause", _m_UnPause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetCustomCurve", _m_SetCustomCurve); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetCustomCurve", _m_GetCustomCurve); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetOutputData", _m_GetOutputData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSpectrumData", _m_GetSpectrumData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSpatializerFloat", _m_SetSpatializerFloat); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSpatializerFloat", _m_GetSpatializerFloat); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAmbisonicDecoderFloat", _m_GetAmbisonicDecoderFloat); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAmbisonicDecoderFloat", _m_SetAmbisonicDecoderFloat); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOFade", _m_DOFade); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOPitch", _m_DOPitch); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "volume", _g_get_volume); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "pitch", _g_get_pitch); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "time", _g_get_time); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "timeSamples", _g_get_timeSamples); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "clip", _g_get_clip); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "outputAudioMixerGroup", _g_get_outputAudioMixerGroup); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isPlaying", _g_get_isPlaying); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isVirtual", _g_get_isVirtual); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "loop", _g_get_loop); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ignoreListenerVolume", _g_get_ignoreListenerVolume); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "playOnAwake", _g_get_playOnAwake); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ignoreListenerPause", _g_get_ignoreListenerPause); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "velocityUpdateMode", _g_get_velocityUpdateMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "panStereo", _g_get_panStereo); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "spatialBlend", _g_get_spatialBlend); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "spatialize", _g_get_spatialize); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "spatializePostEffects", _g_get_spatializePostEffects); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "reverbZoneMix", _g_get_reverbZoneMix); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bypassEffects", _g_get_bypassEffects); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bypassListenerEffects", _g_get_bypassListenerEffects); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bypassReverbZones", _g_get_bypassReverbZones); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "dopplerLevel", _g_get_dopplerLevel); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "spread", _g_get_spread); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "priority", _g_get_priority); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mute", _g_get_mute); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "minDistance", _g_get_minDistance); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "maxDistance", _g_get_maxDistance); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rolloffMode", _g_get_rolloffMode); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "volume", _s_set_volume); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "pitch", _s_set_pitch); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "time", _s_set_time); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "timeSamples", _s_set_timeSamples); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "clip", _s_set_clip); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "outputAudioMixerGroup", _s_set_outputAudioMixerGroup); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "loop", _s_set_loop); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ignoreListenerVolume", _s_set_ignoreListenerVolume); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "playOnAwake", _s_set_playOnAwake); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ignoreListenerPause", _s_set_ignoreListenerPause); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "velocityUpdateMode", _s_set_velocityUpdateMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "panStereo", _s_set_panStereo); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "spatialBlend", _s_set_spatialBlend); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "spatialize", _s_set_spatialize); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "spatializePostEffects", _s_set_spatializePostEffects); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "reverbZoneMix", _s_set_reverbZoneMix); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "bypassEffects", _s_set_bypassEffects); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "bypassListenerEffects", _s_set_bypassListenerEffects); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "bypassReverbZones", _s_set_bypassReverbZones); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "dopplerLevel", _s_set_dopplerLevel); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "spread", _s_set_spread); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "priority", _s_set_priority); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "mute", _s_set_mute); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "minDistance", _s_set_minDistance); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "maxDistance", _s_set_maxDistance); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "rolloffMode", _s_set_rolloffMode); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "PlayClipAtPoint", _m_PlayClipAtPoint_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 UnityEngine.AudioSource(); + 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 UnityEngine.AudioSource constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Play(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.Play( ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) || LuaAPI.lua_isuint64(L, 2))) + { + ulong _delay = LuaAPI.lua_touint64(L, 2); + + gen_to_be_invoked.Play( _delay ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.AudioSource.Play!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PlayDelayed(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + + + + { + float _delay = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.PlayDelayed( _delay ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PlayScheduled(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + + + + { + double _time = LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.PlayScheduled( _time ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PlayOneShot(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.AudioClip _clip = (UnityEngine.AudioClip)translator.GetObject(L, 2, typeof(UnityEngine.AudioClip)); + + gen_to_be_invoked.PlayOneShot( _clip ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.AudioClip _clip = (UnityEngine.AudioClip)translator.GetObject(L, 2, typeof(UnityEngine.AudioClip)); + float _volumeScale = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.PlayOneShot( _clip, _volumeScale ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.AudioSource.PlayOneShot!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetScheduledStartTime(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + + + + { + double _time = LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.SetScheduledStartTime( _time ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetScheduledEndTime(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + + + + { + double _time = LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.SetScheduledEndTime( _time ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Stop(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Stop( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Pause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Pause( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UnPause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.UnPause( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PlayClipAtPoint_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.AudioClip _clip = (UnityEngine.AudioClip)translator.GetObject(L, 1, typeof(UnityEngine.AudioClip)); + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + + UnityEngine.AudioSource.PlayClipAtPoint( _clip, _position ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.AudioClip _clip = (UnityEngine.AudioClip)translator.GetObject(L, 1, typeof(UnityEngine.AudioClip)); + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + float _volume = (float)LuaAPI.lua_tonumber(L, 3); + + UnityEngine.AudioSource.PlayClipAtPoint( _clip, _position, _volume ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.AudioSource.PlayClipAtPoint!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetCustomCurve(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.AudioSourceCurveType _type;translator.Get(L, 2, out _type); + UnityEngine.AnimationCurve _curve = (UnityEngine.AnimationCurve)translator.GetObject(L, 3, typeof(UnityEngine.AnimationCurve)); + + gen_to_be_invoked.SetCustomCurve( _type, _curve ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetCustomCurve(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.AudioSourceCurveType _type;translator.Get(L, 2, out _type); + + var gen_ret = gen_to_be_invoked.GetCustomCurve( _type ); + 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_GetOutputData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + + + + { + float[] _samples = (float[])translator.GetObject(L, 2, typeof(float[])); + int _channel = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.GetOutputData( _samples, _channel ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetSpectrumData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + + + + { + float[] _samples = (float[])translator.GetObject(L, 2, typeof(float[])); + int _channel = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.FFTWindow _window;translator.Get(L, 4, out _window); + + gen_to_be_invoked.GetSpectrumData( _samples, _channel, _window ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSpatializerFloat(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _value = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.SetSpatializerFloat( _index, _value ); + 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_GetSpatializerFloat(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _value; + + var gen_ret = gen_to_be_invoked.GetSpatializerFloat( _index, out _value ); + LuaAPI.lua_pushboolean(L, gen_ret); + LuaAPI.lua_pushnumber(L, _value); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetAmbisonicDecoderFloat(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _value; + + var gen_ret = gen_to_be_invoked.GetAmbisonicDecoderFloat( _index, out _value ); + LuaAPI.lua_pushboolean(L, gen_ret); + LuaAPI.lua_pushnumber(L, _value); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAmbisonicDecoderFloat(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _value = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.SetAmbisonicDecoderFloat( _index, _value ); + 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_DOFade(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + + + + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOFade( _endValue, _duration ); + 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_DOPitch(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + + + + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOPitch( _endValue, _duration ); + 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_volume(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.volume); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_pitch(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.pitch); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_time(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.time); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_timeSamples(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.timeSamples); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_clip(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.clip); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_outputAudioMixerGroup(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.outputAudioMixerGroup); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isPlaying(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isPlaying); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isVirtual(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isVirtual); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_loop(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.loop); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ignoreListenerVolume(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.ignoreListenerVolume); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_playOnAwake(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.playOnAwake); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ignoreListenerPause(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.ignoreListenerPause); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_velocityUpdateMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.velocityUpdateMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_panStereo(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.panStereo); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_spatialBlend(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.spatialBlend); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_spatialize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.spatialize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_spatializePostEffects(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.spatializePostEffects); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_reverbZoneMix(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.reverbZoneMix); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bypassEffects(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.bypassEffects); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bypassListenerEffects(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.bypassListenerEffects); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bypassReverbZones(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.bypassReverbZones); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_dopplerLevel(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.dopplerLevel); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_spread(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.spread); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_priority(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.priority); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mute(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.mute); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_minDistance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.minDistance); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxDistance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.maxDistance); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rolloffMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.rolloffMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_volume(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.volume = (float)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_pitch(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.pitch = (float)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_time(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.time = (float)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_timeSamples(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.timeSamples = 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_clip(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.clip = (UnityEngine.AudioClip)translator.GetObject(L, 2, typeof(UnityEngine.AudioClip)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_outputAudioMixerGroup(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.outputAudioMixerGroup = (UnityEngine.Audio.AudioMixerGroup)translator.GetObject(L, 2, typeof(UnityEngine.Audio.AudioMixerGroup)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_loop(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.loop = 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_ignoreListenerVolume(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ignoreListenerVolume = 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_playOnAwake(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.playOnAwake = 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_ignoreListenerPause(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ignoreListenerPause = 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_velocityUpdateMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + UnityEngine.AudioVelocityUpdateMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.velocityUpdateMode = 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_panStereo(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.panStereo = (float)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_spatialBlend(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.spatialBlend = (float)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_spatialize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.spatialize = 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_spatializePostEffects(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.spatializePostEffects = 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_reverbZoneMix(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.reverbZoneMix = (float)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_bypassEffects(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.bypassEffects = 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_bypassListenerEffects(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.bypassListenerEffects = 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_bypassReverbZones(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.bypassReverbZones = 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_dopplerLevel(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.dopplerLevel = (float)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_spread(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.spread = (float)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_priority(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.priority = 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_mute(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.mute = 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_minDistance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.minDistance = (float)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_maxDistance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.maxDistance = (float)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_rolloffMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.AudioSource gen_to_be_invoked = (UnityEngine.AudioSource)translator.FastGetCSObj(L, 1); + UnityEngine.AudioRolloffMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.rolloffMode = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_AvatarWrap.cs b/Assets/XLua/Gen/UnityEngine_AvatarWrap.cs new file mode 100644 index 000000000..660d4258b --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_AvatarWrap.cs @@ -0,0 +1,112 @@ +#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 UnityEngineAvatarWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Avatar); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 3, 0); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isValid", _g_get_isValid); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isHuman", _g_get_isHuman); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "humanDescription", _g_get_humanDescription); + + + + 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, "UnityEngine.Avatar does not have a constructor!"); + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isValid(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Avatar gen_to_be_invoked = (UnityEngine.Avatar)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isValid); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isHuman(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Avatar gen_to_be_invoked = (UnityEngine.Avatar)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isHuman); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_humanDescription(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Avatar gen_to_be_invoked = (UnityEngine.Avatar)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.humanDescription); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_BehaviourWrap.cs b/Assets/XLua/Gen/UnityEngine_BehaviourWrap.cs new file mode 100644 index 000000000..5b97428d1 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_BehaviourWrap.cs @@ -0,0 +1,130 @@ +#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 UnityEngineBehaviourWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Behaviour); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 1); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enabled", _g_get_enabled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isActiveAndEnabled", _g_get_isActiveAndEnabled); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enabled", _s_set_enabled); + + + 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 UnityEngine.Behaviour(); + 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 UnityEngine.Behaviour constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Behaviour gen_to_be_invoked = (UnityEngine.Behaviour)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_isActiveAndEnabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Behaviour gen_to_be_invoked = (UnityEngine.Behaviour)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isActiveAndEnabled); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Behaviour gen_to_be_invoked = (UnityEngine.Behaviour)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; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_BoundsWrap.cs b/Assets/XLua/Gen/UnityEngine_BoundsWrap.cs new file mode 100644 index 000000000..a3139a9b3 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_BoundsWrap.cs @@ -0,0 +1,737 @@ +#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 UnityEngineBoundsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Bounds); + Utils.BeginObjectRegister(type, L, translator, 1, 11, 5, 5); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__eq", __EqMeta); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Contains", _m_Contains); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SqrDistance", _m_SqrDistance); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClosestPoint", _m_ClosestPoint); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashCode", _m_GetHashCode); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Equals", _m_Equals); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMinMax", _m_SetMinMax); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Encapsulate", _m_Encapsulate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Expand", _m_Expand); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Intersects", _m_Intersects); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IntersectRay", _m_IntersectRay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "center", _g_get_center); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "size", _g_get_size); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "extents", _g_get_extents); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "min", _g_get_min); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "max", _g_get_max); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "center", _s_set_center); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "size", _s_set_size); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "extents", _s_set_extents); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "min", _s_set_min); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "max", _s_set_max); + + + 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 && translator.Assignable(L, 2) && translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _center;translator.Get(L, 2, out _center); + UnityEngine.Vector3 _size;translator.Get(L, 3, out _size); + + var gen_ret = new UnityEngine.Bounds(_center, _size); + translator.PushUnityEngineBounds(L, gen_ret); + + return 1; + } + + if (LuaAPI.lua_gettop(L) == 1) + { + translator.PushUnityEngineBounds(L, default(UnityEngine.Bounds)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Bounds constructor!"); + + } + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __EqMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + UnityEngine.Bounds leftside;translator.Get(L, 1, out leftside); + UnityEngine.Bounds rightside;translator.Get(L, 2, out rightside); + + LuaAPI.lua_pushboolean(L, leftside == rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of == operator, need UnityEngine.Bounds!"); + + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Contains(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.Vector3 _point;translator.Get(L, 2, out _point); + + var gen_ret = gen_to_be_invoked.Contains( _point ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SqrDistance(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.Vector3 _point;translator.Get(L, 2, out _point); + + var gen_ret = gen_to_be_invoked.SqrDistance( _point ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClosestPoint(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.Vector3 _point;translator.Get(L, 2, out _point); + + var gen_ret = gen_to_be_invoked.ClosestPoint( _point ); + translator.PushUnityEngineVector3(L, gen_ret); + + + translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetHashCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.GetHashCode( ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Equals(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _other = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.Equals( _other ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Bounds _other;translator.Get(L, 2, out _other); + + var gen_ret = gen_to_be_invoked.Equals( _other ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Bounds.Equals!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMinMax(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.Vector3 _min;translator.Get(L, 2, out _min); + UnityEngine.Vector3 _max;translator.Get(L, 3, out _max); + + gen_to_be_invoked.SetMinMax( _min, _max ); + + + translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Encapsulate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _point;translator.Get(L, 2, out _point); + + gen_to_be_invoked.Encapsulate( _point ); + + + translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked); + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + + gen_to_be_invoked.Encapsulate( _bounds ); + + + translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Bounds.Encapsulate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Expand(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _amount = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.Expand( _amount ); + + + translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked); + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _amount;translator.Get(L, 2, out _amount); + + gen_to_be_invoked.Expand( _amount ); + + + translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Bounds.Expand!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Intersects(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + + var gen_ret = gen_to_be_invoked.Intersects( _bounds ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IntersectRay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Ray _ray;translator.Get(L, 2, out _ray); + + var gen_ret = gen_to_be_invoked.IntersectRay( _ray ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Ray _ray;translator.Get(L, 2, out _ray); + float _distance; + + var gen_ret = gen_to_be_invoked.IntersectRay( _ray, out _distance ); + LuaAPI.lua_pushboolean(L, gen_ret); + LuaAPI.lua_pushnumber(L, _distance); + + + + translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked); + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Bounds.IntersectRay!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.ToString( ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _format = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.ToString( _format ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _format = LuaAPI.lua_tostring(L, 2); + System.IFormatProvider _formatProvider = (System.IFormatProvider)translator.GetObject(L, 3, typeof(System.IFormatProvider)); + + var gen_ret = gen_to_be_invoked.ToString( _format, _formatProvider ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Bounds.ToString!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_center(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.center); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_size(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.size); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_extents(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.extents); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_min(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.min); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_max(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.max); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_center(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.center = gen_value; + + translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_size(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.size = gen_value; + + translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_extents(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.extents = gen_value; + + translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_min(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.min = gen_value; + + translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_max(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Bounds gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.max = gen_value; + + translator.UpdateUnityEngineBounds(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_BoxColliderWrap.cs b/Assets/XLua/Gen/UnityEngine_BoxColliderWrap.cs new file mode 100644 index 000000000..19035376a --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_BoxColliderWrap.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 UnityEngineBoxColliderWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.BoxCollider); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 2); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "center", _g_get_center); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "size", _g_get_size); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "center", _s_set_center); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "size", _s_set_size); + + + 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 UnityEngine.BoxCollider(); + 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 UnityEngine.BoxCollider constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_center(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.BoxCollider gen_to_be_invoked = (UnityEngine.BoxCollider)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.center); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_size(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.BoxCollider gen_to_be_invoked = (UnityEngine.BoxCollider)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.size); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_center(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.BoxCollider gen_to_be_invoked = (UnityEngine.BoxCollider)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.center = 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_size(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.BoxCollider gen_to_be_invoked = (UnityEngine.BoxCollider)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.size = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_CameraWrap.cs b/Assets/XLua/Gen/UnityEngine_CameraWrap.cs new file mode 100644 index 000000000..9545e3aa4 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_CameraWrap.cs @@ -0,0 +1,3977 @@ +#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; +using DG.Tweening; + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class UnityEngineCameraWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Camera); + Utils.BeginObjectRegister(type, L, translator, 0, 52, 58, 44); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Reset", _m_Reset); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetTransparencySortSettings", _m_ResetTransparencySortSettings); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetAspect", _m_ResetAspect); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetCullingMatrix", _m_ResetCullingMatrix); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetReplacementShader", _m_SetReplacementShader); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetReplacementShader", _m_ResetReplacementShader); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetGateFittedFieldOfView", _m_GetGateFittedFieldOfView); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetGateFittedLensShift", _m_GetGateFittedLensShift); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTargetBuffers", _m_SetTargetBuffers); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetWorldToCameraMatrix", _m_ResetWorldToCameraMatrix); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetProjectionMatrix", _m_ResetProjectionMatrix); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CalculateObliqueMatrix", _m_CalculateObliqueMatrix); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "WorldToScreenPoint", _m_WorldToScreenPoint); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "WorldToViewportPoint", _m_WorldToViewportPoint); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ViewportToWorldPoint", _m_ViewportToWorldPoint); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ScreenToWorldPoint", _m_ScreenToWorldPoint); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ScreenToViewportPoint", _m_ScreenToViewportPoint); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ViewportToScreenPoint", _m_ViewportToScreenPoint); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ViewportPointToRay", _m_ViewportPointToRay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ScreenPointToRay", _m_ScreenPointToRay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CalculateFrustumCorners", _m_CalculateFrustumCorners); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetStereoNonJitteredProjectionMatrix", _m_GetStereoNonJitteredProjectionMatrix); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetStereoViewMatrix", _m_GetStereoViewMatrix); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CopyStereoDeviceProjectionMatrixToNonJittered", _m_CopyStereoDeviceProjectionMatrixToNonJittered); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetStereoProjectionMatrix", _m_GetStereoProjectionMatrix); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetStereoProjectionMatrix", _m_SetStereoProjectionMatrix); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetStereoProjectionMatrices", _m_ResetStereoProjectionMatrices); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetStereoViewMatrix", _m_SetStereoViewMatrix); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetStereoViewMatrices", _m_ResetStereoViewMatrices); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RenderToCubemap", _m_RenderToCubemap); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Render", _m_Render); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RenderWithShader", _m_RenderWithShader); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RenderDontRestore", _m_RenderDontRestore); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SubmitRenderRequests", _m_SubmitRenderRequests); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CopyFrom", _m_CopyFrom); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveCommandBuffers", _m_RemoveCommandBuffers); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveAllCommandBuffers", _m_RemoveAllCommandBuffers); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddCommandBuffer", _m_AddCommandBuffer); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddCommandBufferAsync", _m_AddCommandBufferAsync); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveCommandBuffer", _m_RemoveCommandBuffer); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetCommandBuffers", _m_GetCommandBuffers); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryGetCullingParameters", _m_TryGetCullingParameters); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOAspect", _m_DOAspect); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOColor", _m_DOColor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOFarClipPlane", _m_DOFarClipPlane); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOFieldOfView", _m_DOFieldOfView); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DONearClipPlane", _m_DONearClipPlane); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOOrthoSize", _m_DOOrthoSize); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOPixelRect", _m_DOPixelRect); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DORect", _m_DORect); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOShakePosition", _m_DOShakePosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOShakeRotation", _m_DOShakeRotation); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "nearClipPlane", _g_get_nearClipPlane); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "farClipPlane", _g_get_farClipPlane); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fieldOfView", _g_get_fieldOfView); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "renderingPath", _g_get_renderingPath); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "actualRenderingPath", _g_get_actualRenderingPath); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "allowHDR", _g_get_allowHDR); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "allowMSAA", _g_get_allowMSAA); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "allowDynamicResolution", _g_get_allowDynamicResolution); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "forceIntoRenderTexture", _g_get_forceIntoRenderTexture); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "orthographicSize", _g_get_orthographicSize); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "orthographic", _g_get_orthographic); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "opaqueSortMode", _g_get_opaqueSortMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "transparencySortMode", _g_get_transparencySortMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "transparencySortAxis", _g_get_transparencySortAxis); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "depth", _g_get_depth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "aspect", _g_get_aspect); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "velocity", _g_get_velocity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "cullingMask", _g_get_cullingMask); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "eventMask", _g_get_eventMask); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "layerCullSpherical", _g_get_layerCullSpherical); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "cameraType", _g_get_cameraType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "overrideSceneCullingMask", _g_get_overrideSceneCullingMask); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "layerCullDistances", _g_get_layerCullDistances); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "useOcclusionCulling", _g_get_useOcclusionCulling); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "cullingMatrix", _g_get_cullingMatrix); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "backgroundColor", _g_get_backgroundColor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "clearFlags", _g_get_clearFlags); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "depthTextureMode", _g_get_depthTextureMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "clearStencilAfterLightingPass", _g_get_clearStencilAfterLightingPass); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "usePhysicalProperties", _g_get_usePhysicalProperties); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sensorSize", _g_get_sensorSize); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lensShift", _g_get_lensShift); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "focalLength", _g_get_focalLength); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "gateFit", _g_get_gateFit); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rect", _g_get_rect); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "pixelRect", _g_get_pixelRect); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "pixelWidth", _g_get_pixelWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "pixelHeight", _g_get_pixelHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "scaledPixelWidth", _g_get_scaledPixelWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "scaledPixelHeight", _g_get_scaledPixelHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "targetTexture", _g_get_targetTexture); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "activeTexture", _g_get_activeTexture); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "targetDisplay", _g_get_targetDisplay); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "cameraToWorldMatrix", _g_get_cameraToWorldMatrix); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "worldToCameraMatrix", _g_get_worldToCameraMatrix); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "projectionMatrix", _g_get_projectionMatrix); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "nonJitteredProjectionMatrix", _g_get_nonJitteredProjectionMatrix); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "useJitteredProjectionMatrixForTransparentRendering", _g_get_useJitteredProjectionMatrixForTransparentRendering); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "previousViewProjectionMatrix", _g_get_previousViewProjectionMatrix); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "scene", _g_get_scene); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "stereoEnabled", _g_get_stereoEnabled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "stereoSeparation", _g_get_stereoSeparation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "stereoConvergence", _g_get_stereoConvergence); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "areVRStereoViewMatricesWithinSingleCullTolerance", _g_get_areVRStereoViewMatricesWithinSingleCullTolerance); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "stereoTargetEye", _g_get_stereoTargetEye); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "stereoActiveEye", _g_get_stereoActiveEye); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sceneViewFilterMode", _g_get_sceneViewFilterMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "commandBufferCount", _g_get_commandBufferCount); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "nearClipPlane", _s_set_nearClipPlane); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "farClipPlane", _s_set_farClipPlane); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fieldOfView", _s_set_fieldOfView); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "renderingPath", _s_set_renderingPath); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "allowHDR", _s_set_allowHDR); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "allowMSAA", _s_set_allowMSAA); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "allowDynamicResolution", _s_set_allowDynamicResolution); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "forceIntoRenderTexture", _s_set_forceIntoRenderTexture); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "orthographicSize", _s_set_orthographicSize); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "orthographic", _s_set_orthographic); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "opaqueSortMode", _s_set_opaqueSortMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "transparencySortMode", _s_set_transparencySortMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "transparencySortAxis", _s_set_transparencySortAxis); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "depth", _s_set_depth); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "aspect", _s_set_aspect); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "cullingMask", _s_set_cullingMask); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "eventMask", _s_set_eventMask); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "layerCullSpherical", _s_set_layerCullSpherical); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "cameraType", _s_set_cameraType); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "overrideSceneCullingMask", _s_set_overrideSceneCullingMask); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "layerCullDistances", _s_set_layerCullDistances); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "useOcclusionCulling", _s_set_useOcclusionCulling); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "cullingMatrix", _s_set_cullingMatrix); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "backgroundColor", _s_set_backgroundColor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "clearFlags", _s_set_clearFlags); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "depthTextureMode", _s_set_depthTextureMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "clearStencilAfterLightingPass", _s_set_clearStencilAfterLightingPass); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "usePhysicalProperties", _s_set_usePhysicalProperties); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sensorSize", _s_set_sensorSize); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "lensShift", _s_set_lensShift); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "focalLength", _s_set_focalLength); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "gateFit", _s_set_gateFit); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "rect", _s_set_rect); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "pixelRect", _s_set_pixelRect); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "targetTexture", _s_set_targetTexture); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "targetDisplay", _s_set_targetDisplay); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "worldToCameraMatrix", _s_set_worldToCameraMatrix); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "projectionMatrix", _s_set_projectionMatrix); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "nonJitteredProjectionMatrix", _s_set_nonJitteredProjectionMatrix); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "useJitteredProjectionMatrixForTransparentRendering", _s_set_useJitteredProjectionMatrixForTransparentRendering); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "scene", _s_set_scene); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "stereoSeparation", _s_set_stereoSeparation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "stereoConvergence", _s_set_stereoConvergence); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "stereoTargetEye", _s_set_stereoTargetEye); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 8, 7, 3); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CalculateProjectionMatrixFromPhysicalProperties", _m_CalculateProjectionMatrixFromPhysicalProperties_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FocalLengthToFieldOfView", _m_FocalLengthToFieldOfView_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FieldOfViewToFocalLength", _m_FieldOfViewToFocalLength_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "HorizontalToVerticalFieldOfView", _m_HorizontalToVerticalFieldOfView_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "VerticalToHorizontalFieldOfView", _m_VerticalToHorizontalFieldOfView_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetAllCameras", _m_GetAllCameras_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetupCurrent", _m_SetupCurrent_xlua_st_); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "main", _g_get_main); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "current", _g_get_current); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "allCamerasCount", _g_get_allCamerasCount); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "allCameras", _g_get_allCameras); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "onPreCull", _g_get_onPreCull); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "onPreRender", _g_get_onPreRender); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "onPostRender", _g_get_onPostRender); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "onPreCull", _s_set_onPreCull); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "onPreRender", _s_set_onPreRender); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "onPostRender", _s_set_onPostRender); + + + 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 UnityEngine.Camera(); + 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 UnityEngine.Camera constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Reset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Reset( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetTransparencySortSettings(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ResetTransparencySortSettings( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetAspect(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ResetAspect( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetCullingMatrix(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ResetCullingMatrix( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetReplacementShader(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Shader _shader = (UnityEngine.Shader)translator.GetObject(L, 2, typeof(UnityEngine.Shader)); + string _replacementTag = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.SetReplacementShader( _shader, _replacementTag ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetReplacementShader(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ResetReplacementShader( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetGateFittedFieldOfView(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetGateFittedFieldOfView( ); + LuaAPI.lua_pushnumber(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_GetGateFittedLensShift(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetGateFittedLensShift( ); + translator.PushUnityEngineVector2(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_SetTargetBuffers(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.RenderBuffer _colorBuffer;translator.Get(L, 2, out _colorBuffer); + UnityEngine.RenderBuffer _depthBuffer;translator.Get(L, 3, out _depthBuffer); + + gen_to_be_invoked.SetTargetBuffers( _colorBuffer, _depthBuffer ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.RenderBuffer[] _colorBuffer = (UnityEngine.RenderBuffer[])translator.GetObject(L, 2, typeof(UnityEngine.RenderBuffer[])); + UnityEngine.RenderBuffer _depthBuffer;translator.Get(L, 3, out _depthBuffer); + + gen_to_be_invoked.SetTargetBuffers( _colorBuffer, _depthBuffer ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Camera.SetTargetBuffers!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetWorldToCameraMatrix(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ResetWorldToCameraMatrix( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetProjectionMatrix(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ResetProjectionMatrix( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalculateObliqueMatrix(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector4 _clipPlane;translator.Get(L, 2, out _clipPlane); + + var gen_ret = gen_to_be_invoked.CalculateObliqueMatrix( _clipPlane ); + 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_WorldToScreenPoint(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + + var gen_ret = gen_to_be_invoked.WorldToScreenPoint( _position ); + translator.PushUnityEngineVector3(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + UnityEngine.Camera.MonoOrStereoscopicEye _eye;translator.Get(L, 3, out _eye); + + var gen_ret = gen_to_be_invoked.WorldToScreenPoint( _position, _eye ); + translator.PushUnityEngineVector3(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 UnityEngine.Camera.WorldToScreenPoint!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_WorldToViewportPoint(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + + var gen_ret = gen_to_be_invoked.WorldToViewportPoint( _position ); + translator.PushUnityEngineVector3(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + UnityEngine.Camera.MonoOrStereoscopicEye _eye;translator.Get(L, 3, out _eye); + + var gen_ret = gen_to_be_invoked.WorldToViewportPoint( _position, _eye ); + translator.PushUnityEngineVector3(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 UnityEngine.Camera.WorldToViewportPoint!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ViewportToWorldPoint(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + + var gen_ret = gen_to_be_invoked.ViewportToWorldPoint( _position ); + translator.PushUnityEngineVector3(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + UnityEngine.Camera.MonoOrStereoscopicEye _eye;translator.Get(L, 3, out _eye); + + var gen_ret = gen_to_be_invoked.ViewportToWorldPoint( _position, _eye ); + translator.PushUnityEngineVector3(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 UnityEngine.Camera.ViewportToWorldPoint!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ScreenToWorldPoint(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + + var gen_ret = gen_to_be_invoked.ScreenToWorldPoint( _position ); + translator.PushUnityEngineVector3(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + UnityEngine.Camera.MonoOrStereoscopicEye _eye;translator.Get(L, 3, out _eye); + + var gen_ret = gen_to_be_invoked.ScreenToWorldPoint( _position, _eye ); + translator.PushUnityEngineVector3(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 UnityEngine.Camera.ScreenToWorldPoint!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ScreenToViewportPoint(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + + var gen_ret = gen_to_be_invoked.ScreenToViewportPoint( _position ); + translator.PushUnityEngineVector3(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_ViewportToScreenPoint(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + + var gen_ret = gen_to_be_invoked.ViewportToScreenPoint( _position ); + translator.PushUnityEngineVector3(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_ViewportPointToRay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _pos;translator.Get(L, 2, out _pos); + + var gen_ret = gen_to_be_invoked.ViewportPointToRay( _pos ); + translator.PushUnityEngineRay(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _pos;translator.Get(L, 2, out _pos); + UnityEngine.Camera.MonoOrStereoscopicEye _eye;translator.Get(L, 3, out _eye); + + var gen_ret = gen_to_be_invoked.ViewportPointToRay( _pos, _eye ); + translator.PushUnityEngineRay(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 UnityEngine.Camera.ViewportPointToRay!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ScreenPointToRay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _pos;translator.Get(L, 2, out _pos); + + var gen_ret = gen_to_be_invoked.ScreenPointToRay( _pos ); + translator.PushUnityEngineRay(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _pos;translator.Get(L, 2, out _pos); + UnityEngine.Camera.MonoOrStereoscopicEye _eye;translator.Get(L, 3, out _eye); + + var gen_ret = gen_to_be_invoked.ScreenPointToRay( _pos, _eye ); + translator.PushUnityEngineRay(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 UnityEngine.Camera.ScreenPointToRay!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalculateFrustumCorners(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Rect _viewport;translator.Get(L, 2, out _viewport); + float _z = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Camera.MonoOrStereoscopicEye _eye;translator.Get(L, 4, out _eye); + UnityEngine.Vector3[] _outCorners = (UnityEngine.Vector3[])translator.GetObject(L, 5, typeof(UnityEngine.Vector3[])); + + gen_to_be_invoked.CalculateFrustumCorners( _viewport, _z, _eye, _outCorners ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalculateProjectionMatrixFromPhysicalProperties_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)) + { + UnityEngine.Matrix4x4 _output; + float _focalLength = (float)LuaAPI.lua_tonumber(L, 1); + UnityEngine.Vector2 _sensorSize;translator.Get(L, 2, out _sensorSize); + UnityEngine.Vector2 _lensShift;translator.Get(L, 3, out _lensShift); + float _nearClip = (float)LuaAPI.lua_tonumber(L, 4); + float _farClip = (float)LuaAPI.lua_tonumber(L, 5); + UnityEngine.Camera.GateFitParameters _gateFitParameters;translator.Get(L, 6, out _gateFitParameters); + + UnityEngine.Camera.CalculateProjectionMatrixFromPhysicalProperties( out _output, _focalLength, _sensorSize, _lensShift, _nearClip, _farClip, _gateFitParameters ); + translator.Push(L, _output); + + + + + return 1; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Matrix4x4 _output; + float _focalLength = (float)LuaAPI.lua_tonumber(L, 1); + UnityEngine.Vector2 _sensorSize;translator.Get(L, 2, out _sensorSize); + UnityEngine.Vector2 _lensShift;translator.Get(L, 3, out _lensShift); + float _nearClip = (float)LuaAPI.lua_tonumber(L, 4); + float _farClip = (float)LuaAPI.lua_tonumber(L, 5); + + UnityEngine.Camera.CalculateProjectionMatrixFromPhysicalProperties( out _output, _focalLength, _sensorSize, _lensShift, _nearClip, _farClip ); + translator.Push(L, _output); + + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Camera.CalculateProjectionMatrixFromPhysicalProperties!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FocalLengthToFieldOfView_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _focalLength = (float)LuaAPI.lua_tonumber(L, 1); + float _sensorSize = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = UnityEngine.Camera.FocalLengthToFieldOfView( _focalLength, _sensorSize ); + LuaAPI.lua_pushnumber(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_FieldOfViewToFocalLength_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _fieldOfView = (float)LuaAPI.lua_tonumber(L, 1); + float _sensorSize = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = UnityEngine.Camera.FieldOfViewToFocalLength( _fieldOfView, _sensorSize ); + LuaAPI.lua_pushnumber(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_HorizontalToVerticalFieldOfView_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _horizontalFieldOfView = (float)LuaAPI.lua_tonumber(L, 1); + float _aspectRatio = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = UnityEngine.Camera.HorizontalToVerticalFieldOfView( _horizontalFieldOfView, _aspectRatio ); + LuaAPI.lua_pushnumber(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_VerticalToHorizontalFieldOfView_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _verticalFieldOfView = (float)LuaAPI.lua_tonumber(L, 1); + float _aspectRatio = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = UnityEngine.Camera.VerticalToHorizontalFieldOfView( _verticalFieldOfView, _aspectRatio ); + LuaAPI.lua_pushnumber(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_GetStereoNonJitteredProjectionMatrix(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Camera.StereoscopicEye _eye;translator.Get(L, 2, out _eye); + + var gen_ret = gen_to_be_invoked.GetStereoNonJitteredProjectionMatrix( _eye ); + 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_GetStereoViewMatrix(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Camera.StereoscopicEye _eye;translator.Get(L, 2, out _eye); + + var gen_ret = gen_to_be_invoked.GetStereoViewMatrix( _eye ); + 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_CopyStereoDeviceProjectionMatrixToNonJittered(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Camera.StereoscopicEye _eye;translator.Get(L, 2, out _eye); + + gen_to_be_invoked.CopyStereoDeviceProjectionMatrixToNonJittered( _eye ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetStereoProjectionMatrix(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Camera.StereoscopicEye _eye;translator.Get(L, 2, out _eye); + + var gen_ret = gen_to_be_invoked.GetStereoProjectionMatrix( _eye ); + 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_SetStereoProjectionMatrix(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Camera.StereoscopicEye _eye;translator.Get(L, 2, out _eye); + UnityEngine.Matrix4x4 _matrix;translator.Get(L, 3, out _matrix); + + gen_to_be_invoked.SetStereoProjectionMatrix( _eye, _matrix ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetStereoProjectionMatrices(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ResetStereoProjectionMatrices( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetStereoViewMatrix(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Camera.StereoscopicEye _eye;translator.Get(L, 2, out _eye); + UnityEngine.Matrix4x4 _matrix;translator.Get(L, 3, out _matrix); + + gen_to_be_invoked.SetStereoViewMatrix( _eye, _matrix ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetStereoViewMatrices(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ResetStereoViewMatrices( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetAllCameras_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Camera[] _cameras = (UnityEngine.Camera[])translator.GetObject(L, 1, typeof(UnityEngine.Camera[])); + + var gen_ret = UnityEngine.Camera.GetAllCameras( _cameras ); + 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_RenderToCubemap(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Cubemap _cubemap = (UnityEngine.Cubemap)translator.GetObject(L, 2, typeof(UnityEngine.Cubemap)); + + var gen_ret = gen_to_be_invoked.RenderToCubemap( _cubemap ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.RenderTexture _cubemap = (UnityEngine.RenderTexture)translator.GetObject(L, 2, typeof(UnityEngine.RenderTexture)); + + var gen_ret = gen_to_be_invoked.RenderToCubemap( _cubemap ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Cubemap _cubemap = (UnityEngine.Cubemap)translator.GetObject(L, 2, typeof(UnityEngine.Cubemap)); + int _faceMask = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.RenderToCubemap( _cubemap, _faceMask ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.RenderTexture _cubemap = (UnityEngine.RenderTexture)translator.GetObject(L, 2, typeof(UnityEngine.RenderTexture)); + int _faceMask = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.RenderToCubemap( _cubemap, _faceMask ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.RenderTexture _cubemap = (UnityEngine.RenderTexture)translator.GetObject(L, 2, typeof(UnityEngine.RenderTexture)); + int _faceMask = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.Camera.MonoOrStereoscopicEye _stereoEye;translator.Get(L, 4, out _stereoEye); + + var gen_ret = gen_to_be_invoked.RenderToCubemap( _cubemap, _faceMask, _stereoEye ); + LuaAPI.lua_pushboolean(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 UnityEngine.Camera.RenderToCubemap!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Render(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Render( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RenderWithShader(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Shader _shader = (UnityEngine.Shader)translator.GetObject(L, 2, typeof(UnityEngine.Shader)); + string _replacementTag = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.RenderWithShader( _shader, _replacementTag ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RenderDontRestore(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RenderDontRestore( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SubmitRenderRequests(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.List _renderRequests = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.SubmitRenderRequests( _renderRequests ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetupCurrent_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Camera _cur = (UnityEngine.Camera)translator.GetObject(L, 1, typeof(UnityEngine.Camera)); + + UnityEngine.Camera.SetupCurrent( _cur ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CopyFrom(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Camera _other = (UnityEngine.Camera)translator.GetObject(L, 2, typeof(UnityEngine.Camera)); + + gen_to_be_invoked.CopyFrom( _other ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveCommandBuffers(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Rendering.CameraEvent _evt;translator.Get(L, 2, out _evt); + + gen_to_be_invoked.RemoveCommandBuffers( _evt ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveAllCommandBuffers(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RemoveAllCommandBuffers( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddCommandBuffer(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Rendering.CameraEvent _evt;translator.Get(L, 2, out _evt); + UnityEngine.Rendering.CommandBuffer _buffer = (UnityEngine.Rendering.CommandBuffer)translator.GetObject(L, 3, typeof(UnityEngine.Rendering.CommandBuffer)); + + gen_to_be_invoked.AddCommandBuffer( _evt, _buffer ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddCommandBufferAsync(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Rendering.CameraEvent _evt;translator.Get(L, 2, out _evt); + UnityEngine.Rendering.CommandBuffer _buffer = (UnityEngine.Rendering.CommandBuffer)translator.GetObject(L, 3, typeof(UnityEngine.Rendering.CommandBuffer)); + UnityEngine.Rendering.ComputeQueueType _queueType;translator.Get(L, 4, out _queueType); + + gen_to_be_invoked.AddCommandBufferAsync( _evt, _buffer, _queueType ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveCommandBuffer(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Rendering.CameraEvent _evt;translator.Get(L, 2, out _evt); + UnityEngine.Rendering.CommandBuffer _buffer = (UnityEngine.Rendering.CommandBuffer)translator.GetObject(L, 3, typeof(UnityEngine.Rendering.CommandBuffer)); + + gen_to_be_invoked.RemoveCommandBuffer( _evt, _buffer ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetCommandBuffers(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Rendering.CameraEvent _evt;translator.Get(L, 2, out _evt); + + var gen_ret = gen_to_be_invoked.GetCommandBuffers( _evt ); + 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_TryGetCullingParameters(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + UnityEngine.Rendering.ScriptableCullingParameters _cullingParameters; + + var gen_ret = gen_to_be_invoked.TryGetCullingParameters( out _cullingParameters ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _cullingParameters); + + + + + return 2; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _stereoAware = LuaAPI.lua_toboolean(L, 2); + UnityEngine.Rendering.ScriptableCullingParameters _cullingParameters; + + var gen_ret = gen_to_be_invoked.TryGetCullingParameters( _stereoAware, out _cullingParameters ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _cullingParameters); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Camera.TryGetCullingParameters!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOAspect(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOAspect( _endValue, _duration ); + 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_DOColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Color _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOColor( _endValue, _duration ); + 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_DOFarClipPlane(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOFarClipPlane( _endValue, _duration ); + 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_DOFieldOfView(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOFieldOfView( _endValue, _duration ); + 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_DONearClipPlane(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DONearClipPlane( _endValue, _duration ); + 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_DOOrthoSize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOOrthoSize( _endValue, _duration ); + 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_DOPixelRect(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Rect _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOPixelRect( _endValue, _duration ); + 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_DORect(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Rect _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DORect( _endValue, _duration ); + 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_DOShakePosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + float _strength = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _randomness = (float)LuaAPI.lua_tonumber(L, 5); + bool _fadeOut = LuaAPI.lua_toboolean(L, 6); + + var gen_ret = gen_to_be_invoked.DOShakePosition( _duration, _strength, _vibrato, _randomness, _fadeOut ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + float _strength = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _randomness = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = gen_to_be_invoked.DOShakePosition( _duration, _strength, _vibrato, _randomness ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + float _strength = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.DOShakePosition( _duration, _strength, _vibrato ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + float _strength = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOShakePosition( _duration, _strength ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.DOShakePosition( _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _strength;translator.Get(L, 3, out _strength); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _randomness = (float)LuaAPI.lua_tonumber(L, 5); + bool _fadeOut = LuaAPI.lua_toboolean(L, 6); + + var gen_ret = gen_to_be_invoked.DOShakePosition( _duration, _strength, _vibrato, _randomness, _fadeOut ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _strength;translator.Get(L, 3, out _strength); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _randomness = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = gen_to_be_invoked.DOShakePosition( _duration, _strength, _vibrato, _randomness ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _strength;translator.Get(L, 3, out _strength); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.DOShakePosition( _duration, _strength, _vibrato ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _strength;translator.Get(L, 3, out _strength); + + var gen_ret = gen_to_be_invoked.DOShakePosition( _duration, _strength ); + 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 UnityEngine.Camera.DOShakePosition!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOShakeRotation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + float _strength = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _randomness = (float)LuaAPI.lua_tonumber(L, 5); + bool _fadeOut = LuaAPI.lua_toboolean(L, 6); + + var gen_ret = gen_to_be_invoked.DOShakeRotation( _duration, _strength, _vibrato, _randomness, _fadeOut ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + float _strength = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _randomness = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = gen_to_be_invoked.DOShakeRotation( _duration, _strength, _vibrato, _randomness ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + float _strength = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.DOShakeRotation( _duration, _strength, _vibrato ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + float _strength = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOShakeRotation( _duration, _strength ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.DOShakeRotation( _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _strength;translator.Get(L, 3, out _strength); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _randomness = (float)LuaAPI.lua_tonumber(L, 5); + bool _fadeOut = LuaAPI.lua_toboolean(L, 6); + + var gen_ret = gen_to_be_invoked.DOShakeRotation( _duration, _strength, _vibrato, _randomness, _fadeOut ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _strength;translator.Get(L, 3, out _strength); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _randomness = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = gen_to_be_invoked.DOShakeRotation( _duration, _strength, _vibrato, _randomness ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _strength;translator.Get(L, 3, out _strength); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.DOShakeRotation( _duration, _strength, _vibrato ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _strength;translator.Get(L, 3, out _strength); + + var gen_ret = gen_to_be_invoked.DOShakeRotation( _duration, _strength ); + 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 UnityEngine.Camera.DOShakeRotation!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_nearClipPlane(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.nearClipPlane); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_farClipPlane(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.farClipPlane); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fieldOfView(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.fieldOfView); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_renderingPath(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.renderingPath); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_actualRenderingPath(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.actualRenderingPath); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_allowHDR(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.allowHDR); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_allowMSAA(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.allowMSAA); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_allowDynamicResolution(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.allowDynamicResolution); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_forceIntoRenderTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.forceIntoRenderTexture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_orthographicSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.orthographicSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_orthographic(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.orthographic); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_opaqueSortMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.opaqueSortMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_transparencySortMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineTransparencySortMode(L, gen_to_be_invoked.transparencySortMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_transparencySortAxis(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.transparencySortAxis); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_depth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.depth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_aspect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.aspect); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_velocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.velocity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cullingMask(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.cullingMask); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_eventMask(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.eventMask); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_layerCullSpherical(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.layerCullSpherical); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cameraType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.cameraType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_overrideSceneCullingMask(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushuint64(L, gen_to_be_invoked.overrideSceneCullingMask); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_layerCullDistances(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.layerCullDistances); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_useOcclusionCulling(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.useOcclusionCulling); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cullingMatrix(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.cullingMatrix); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_backgroundColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineColor(L, gen_to_be_invoked.backgroundColor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_clearFlags(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.clearFlags); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_depthTextureMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.depthTextureMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_clearStencilAfterLightingPass(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.clearStencilAfterLightingPass); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_usePhysicalProperties(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.usePhysicalProperties); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sensorSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.sensorSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lensShift(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.lensShift); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_focalLength(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.focalLength); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_gateFit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineCameraGateFitMode(L, gen_to_be_invoked.gateFit); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.rect); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_pixelRect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.pixelRect); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_pixelWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.pixelWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_pixelHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.pixelHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_scaledPixelWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.scaledPixelWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_scaledPixelHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.scaledPixelHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_targetTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.targetTexture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_activeTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.activeTexture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_targetDisplay(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.targetDisplay); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cameraToWorldMatrix(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.cameraToWorldMatrix); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_worldToCameraMatrix(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.worldToCameraMatrix); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_projectionMatrix(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.projectionMatrix); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_nonJitteredProjectionMatrix(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.nonJitteredProjectionMatrix); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_useJitteredProjectionMatrixForTransparentRendering(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.useJitteredProjectionMatrixForTransparentRendering); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_previousViewProjectionMatrix(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.previousViewProjectionMatrix); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_main(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Camera.main); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_current(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Camera.current); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_scene(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.scene); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_stereoEnabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.stereoEnabled); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_stereoSeparation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.stereoSeparation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_stereoConvergence(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.stereoConvergence); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_areVRStereoViewMatricesWithinSingleCullTolerance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.areVRStereoViewMatricesWithinSingleCullTolerance); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_stereoTargetEye(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.stereoTargetEye); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_stereoActiveEye(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineCameraMonoOrStereoscopicEye(L, gen_to_be_invoked.stereoActiveEye); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_allCamerasCount(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.Camera.allCamerasCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_allCameras(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Camera.allCameras); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sceneViewFilterMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineCameraSceneViewFilterMode(L, gen_to_be_invoked.sceneViewFilterMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_commandBufferCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.commandBufferCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onPreCull(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Camera.onPreCull); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onPreRender(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Camera.onPreRender); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onPostRender(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Camera.onPostRender); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_nearClipPlane(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.nearClipPlane = (float)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_farClipPlane(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.farClipPlane = (float)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_fieldOfView(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.fieldOfView = (float)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_renderingPath(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + UnityEngine.RenderingPath gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.renderingPath = 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_allowHDR(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.allowHDR = 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_allowMSAA(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.allowMSAA = 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_allowDynamicResolution(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.allowDynamicResolution = 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_forceIntoRenderTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.forceIntoRenderTexture = 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_orthographicSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.orthographicSize = (float)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_orthographic(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.orthographic = 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_opaqueSortMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + UnityEngine.Rendering.OpaqueSortMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.opaqueSortMode = 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_transparencySortMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + UnityEngine.TransparencySortMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.transparencySortMode = 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_transparencySortAxis(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.transparencySortAxis = 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_depth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.depth = (float)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_aspect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.aspect = (float)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_cullingMask(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.cullingMask = 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_eventMask(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.eventMask = 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_layerCullSpherical(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.layerCullSpherical = 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_cameraType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + UnityEngine.CameraType gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.cameraType = 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_overrideSceneCullingMask(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.overrideSceneCullingMask = LuaAPI.lua_touint64(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_layerCullDistances(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.layerCullDistances = (float[])translator.GetObject(L, 2, typeof(float[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_useOcclusionCulling(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.useOcclusionCulling = 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_cullingMatrix(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + UnityEngine.Matrix4x4 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.cullingMatrix = 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_backgroundColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + UnityEngine.Color gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.backgroundColor = 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_clearFlags(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + UnityEngine.CameraClearFlags gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.clearFlags = 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_depthTextureMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + UnityEngine.DepthTextureMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.depthTextureMode = 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_clearStencilAfterLightingPass(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.clearStencilAfterLightingPass = 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_usePhysicalProperties(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.usePhysicalProperties = 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_sensorSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.sensorSize = 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_lensShift(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.lensShift = 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_focalLength(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.focalLength = (float)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_gateFit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + UnityEngine.Camera.GateFitMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.gateFit = 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_rect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + UnityEngine.Rect gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.rect = 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_pixelRect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + UnityEngine.Rect gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.pixelRect = 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_targetTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.targetTexture = (UnityEngine.RenderTexture)translator.GetObject(L, 2, typeof(UnityEngine.RenderTexture)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_targetDisplay(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.targetDisplay = 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_worldToCameraMatrix(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + UnityEngine.Matrix4x4 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.worldToCameraMatrix = 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_projectionMatrix(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + UnityEngine.Matrix4x4 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.projectionMatrix = 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_nonJitteredProjectionMatrix(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + UnityEngine.Matrix4x4 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.nonJitteredProjectionMatrix = 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_useJitteredProjectionMatrixForTransparentRendering(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.useJitteredProjectionMatrixForTransparentRendering = 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_scene(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + UnityEngine.SceneManagement.Scene gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.scene = 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_stereoSeparation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.stereoSeparation = (float)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_stereoConvergence(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.stereoConvergence = (float)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_stereoTargetEye(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera gen_to_be_invoked = (UnityEngine.Camera)translator.FastGetCSObj(L, 1); + UnityEngine.StereoTargetEyeMask gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.stereoTargetEye = 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_onPreCull(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + UnityEngine.Camera.onPreCull = translator.GetDelegate(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_onPreRender(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + UnityEngine.Camera.onPreRender = translator.GetDelegate(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_onPostRender(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + UnityEngine.Camera.onPostRender = translator.GetDelegate(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_Camera_GateFitParametersWrap.cs b/Assets/XLua/Gen/UnityEngine_Camera_GateFitParametersWrap.cs new file mode 100644 index 000000000..a95cb5b5f --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_Camera_GateFitParametersWrap.cs @@ -0,0 +1,159 @@ +#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 UnityEngineCameraGateFitParametersWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Camera.GateFitParameters); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 2); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mode", _g_get_mode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "aspect", _g_get_aspect); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "mode", _s_set_mode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "aspect", _s_set_aspect); + + + 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 && translator.Assignable(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Camera.GateFitMode _mode;translator.Get(L, 2, out _mode); + float _aspect = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = new UnityEngine.Camera.GateFitParameters(_mode, _aspect); + translator.Push(L, gen_ret); + + return 1; + } + + if (LuaAPI.lua_gettop(L) == 1) + { + translator.Push(L, default(UnityEngine.Camera.GateFitParameters)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Camera.GateFitParameters constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera.GateFitParameters gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineCameraGateFitMode(L, gen_to_be_invoked.mode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_aspect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera.GateFitParameters gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.aspect); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_mode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera.GateFitParameters gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Camera.GateFitMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.mode = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_aspect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera.GateFitParameters gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.aspect = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_Camera_RenderRequestWrap.cs b/Assets/XLua/Gen/UnityEngine_Camera_RenderRequestWrap.cs new file mode 100644 index 000000000..19b5552cf --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_Camera_RenderRequestWrap.cs @@ -0,0 +1,163 @@ +#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 UnityEngineCameraRenderRequestWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Camera.RenderRequest); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 4, 0); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isValid", _g_get_isValid); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mode", _g_get_mode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "result", _g_get_result); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "outputSpace", _g_get_outputSpace); + + + + 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 && translator.Assignable(L, 2) && translator.Assignable(L, 3)) + { + UnityEngine.Camera.RenderRequestMode _mode;translator.Get(L, 2, out _mode); + UnityEngine.RenderTexture _rt = (UnityEngine.RenderTexture)translator.GetObject(L, 3, typeof(UnityEngine.RenderTexture)); + + var gen_ret = new UnityEngine.Camera.RenderRequest(_mode, _rt); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 4 && translator.Assignable(L, 2) && translator.Assignable(L, 3) && translator.Assignable(L, 4)) + { + UnityEngine.Camera.RenderRequestMode _mode;translator.Get(L, 2, out _mode); + UnityEngine.Camera.RenderRequestOutputSpace _space;translator.Get(L, 3, out _space); + UnityEngine.RenderTexture _rt = (UnityEngine.RenderTexture)translator.GetObject(L, 4, typeof(UnityEngine.RenderTexture)); + + var gen_ret = new UnityEngine.Camera.RenderRequest(_mode, _space, _rt); + translator.Push(L, gen_ret); + + return 1; + } + + if (LuaAPI.lua_gettop(L) == 1) + { + translator.Push(L, default(UnityEngine.Camera.RenderRequest)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Camera.RenderRequest constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isValid(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera.RenderRequest gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isValid); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera.RenderRequest gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineCameraRenderRequestMode(L, gen_to_be_invoked.mode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_result(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera.RenderRequest gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.result); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_outputSpace(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Camera.RenderRequest gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineCameraRenderRequestOutputSpace(L, gen_to_be_invoked.outputSpace); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_CanvasGroupWrap.cs b/Assets/XLua/Gen/UnityEngine_CanvasGroupWrap.cs new file mode 100644 index 000000000..70c259a81 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_CanvasGroupWrap.cs @@ -0,0 +1,270 @@ +#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; +using DG.Tweening; + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class UnityEngineCanvasGroupWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.CanvasGroup); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 4, 4); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsRaycastLocationValid", _m_IsRaycastLocationValid); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOFade", _m_DOFade); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "alpha", _g_get_alpha); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "interactable", _g_get_interactable); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "blocksRaycasts", _g_get_blocksRaycasts); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ignoreParentGroups", _g_get_ignoreParentGroups); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "alpha", _s_set_alpha); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "interactable", _s_set_interactable); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "blocksRaycasts", _s_set_blocksRaycasts); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ignoreParentGroups", _s_set_ignoreParentGroups); + + + 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 UnityEngine.CanvasGroup(); + 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 UnityEngine.CanvasGroup constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsRaycastLocationValid(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.CanvasGroup gen_to_be_invoked = (UnityEngine.CanvasGroup)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector2 _sp;translator.Get(L, 2, out _sp); + UnityEngine.Camera _eventCamera = (UnityEngine.Camera)translator.GetObject(L, 3, typeof(UnityEngine.Camera)); + + var gen_ret = gen_to_be_invoked.IsRaycastLocationValid( _sp, _eventCamera ); + 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_DOFade(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.CanvasGroup gen_to_be_invoked = (UnityEngine.CanvasGroup)translator.FastGetCSObj(L, 1); + + + + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOFade( _endValue, _duration ); + 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_alpha(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.CanvasGroup gen_to_be_invoked = (UnityEngine.CanvasGroup)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.alpha); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_interactable(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.CanvasGroup gen_to_be_invoked = (UnityEngine.CanvasGroup)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.interactable); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_blocksRaycasts(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.CanvasGroup gen_to_be_invoked = (UnityEngine.CanvasGroup)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.blocksRaycasts); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ignoreParentGroups(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.CanvasGroup gen_to_be_invoked = (UnityEngine.CanvasGroup)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.ignoreParentGroups); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_alpha(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.CanvasGroup gen_to_be_invoked = (UnityEngine.CanvasGroup)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.alpha = (float)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_interactable(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.CanvasGroup gen_to_be_invoked = (UnityEngine.CanvasGroup)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.interactable = 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_blocksRaycasts(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.CanvasGroup gen_to_be_invoked = (UnityEngine.CanvasGroup)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.blocksRaycasts = 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_ignoreParentGroups(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.CanvasGroup gen_to_be_invoked = (UnityEngine.CanvasGroup)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ignoreParentGroups = LuaAPI.lua_toboolean(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_CanvasRendererWrap.cs b/Assets/XLua/Gen/UnityEngine_CanvasRendererWrap.cs new file mode 100644 index 000000000..ed433dd8e --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_CanvasRendererWrap.cs @@ -0,0 +1,966 @@ +#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 UnityEngineCanvasRendererWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.CanvasRenderer); + Utils.BeginObjectRegister(type, L, translator, 0, 15, 10, 6); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetColor", _m_SetColor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetColor", _m_GetColor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "EnableRectClipping", _m_EnableRectClipping); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DisableRectClipping", _m_DisableRectClipping); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMaterial", _m_SetMaterial); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetMaterial", _m_GetMaterial); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPopMaterial", _m_SetPopMaterial); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPopMaterial", _m_GetPopMaterial); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTexture", _m_SetTexture); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAlphaTexture", _m_SetAlphaTexture); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMesh", _m_SetMesh); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAlpha", _m_GetAlpha); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAlpha", _m_SetAlpha); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetInheritedAlpha", _m_GetInheritedAlpha); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "hasPopInstruction", _g_get_hasPopInstruction); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "materialCount", _g_get_materialCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "popMaterialCount", _g_get_popMaterialCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "absoluteDepth", _g_get_absoluteDepth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "hasMoved", _g_get_hasMoved); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "cullTransparentMesh", _g_get_cullTransparentMesh); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "hasRectClipping", _g_get_hasRectClipping); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "relativeDepth", _g_get_relativeDepth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "cull", _g_get_cull); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "clippingSoftness", _g_get_clippingSoftness); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "hasPopInstruction", _s_set_hasPopInstruction); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "materialCount", _s_set_materialCount); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "popMaterialCount", _s_set_popMaterialCount); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "cullTransparentMesh", _s_set_cullTransparentMesh); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "cull", _s_set_cull); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "clippingSoftness", _s_set_clippingSoftness); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 4, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SplitUIVertexStreams", _m_SplitUIVertexStreams_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CreateUIVertexStream", _m_CreateUIVertexStream_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "AddUIVertexStream", _m_AddUIVertexStream_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 UnityEngine.CanvasRenderer(); + 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 UnityEngine.CanvasRenderer constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Color _color;translator.Get(L, 2, out _color); + + gen_to_be_invoked.SetColor( _color ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetColor( ); + translator.PushUnityEngineColor(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_EnableRectClipping(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Rect _rect;translator.Get(L, 2, out _rect); + + gen_to_be_invoked.EnableRectClipping( _rect ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DisableRectClipping(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.DisableRectClipping( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMaterial(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + int _index = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetMaterial( _material, _index ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + UnityEngine.Texture _texture = (UnityEngine.Texture)translator.GetObject(L, 3, typeof(UnityEngine.Texture)); + + gen_to_be_invoked.SetMaterial( _material, _texture ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.CanvasRenderer.SetMaterial!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetMaterial(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.GetMaterial( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetMaterial( _index ); + 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 UnityEngine.CanvasRenderer.GetMaterial!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetPopMaterial(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + int _index = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetPopMaterial( _material, _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetPopMaterial(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetPopMaterial( _index ); + 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_SetTexture(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Texture _texture = (UnityEngine.Texture)translator.GetObject(L, 2, typeof(UnityEngine.Texture)); + + gen_to_be_invoked.SetTexture( _texture ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAlphaTexture(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Texture _texture = (UnityEngine.Texture)translator.GetObject(L, 2, typeof(UnityEngine.Texture)); + + gen_to_be_invoked.SetAlphaTexture( _texture ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMesh(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + + gen_to_be_invoked.SetMesh( _mesh ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Clear(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Clear( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetAlpha(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetAlpha( ); + LuaAPI.lua_pushnumber(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_SetAlpha(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + + + + { + float _alpha = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.SetAlpha( _alpha ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetInheritedAlpha(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetInheritedAlpha( ); + LuaAPI.lua_pushnumber(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_SplitUIVertexStreams_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 8&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& translator.Assignable>(L, 3)&& translator.Assignable>(L, 4)&& translator.Assignable>(L, 5)&& translator.Assignable>(L, 6)&& translator.Assignable>(L, 7)&& translator.Assignable>(L, 8)) + { + System.Collections.Generic.List _verts = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _positions = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _colors = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _uv0S = (System.Collections.Generic.List)translator.GetObject(L, 4, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _uv1S = (System.Collections.Generic.List)translator.GetObject(L, 5, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _normals = (System.Collections.Generic.List)translator.GetObject(L, 6, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _tangents = (System.Collections.Generic.List)translator.GetObject(L, 7, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _indices = (System.Collections.Generic.List)translator.GetObject(L, 8, typeof(System.Collections.Generic.List)); + + UnityEngine.CanvasRenderer.SplitUIVertexStreams( _verts, _positions, _colors, _uv0S, _uv1S, _normals, _tangents, _indices ); + + + + return 0; + } + if(gen_param_count == 10&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& translator.Assignable>(L, 3)&& translator.Assignable>(L, 4)&& translator.Assignable>(L, 5)&& translator.Assignable>(L, 6)&& translator.Assignable>(L, 7)&& translator.Assignable>(L, 8)&& translator.Assignable>(L, 9)&& translator.Assignable>(L, 10)) + { + System.Collections.Generic.List _verts = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _positions = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _colors = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _uv0S = (System.Collections.Generic.List)translator.GetObject(L, 4, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _uv1S = (System.Collections.Generic.List)translator.GetObject(L, 5, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _uv2S = (System.Collections.Generic.List)translator.GetObject(L, 6, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _uv3S = (System.Collections.Generic.List)translator.GetObject(L, 7, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _normals = (System.Collections.Generic.List)translator.GetObject(L, 8, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _tangents = (System.Collections.Generic.List)translator.GetObject(L, 9, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _indices = (System.Collections.Generic.List)translator.GetObject(L, 10, typeof(System.Collections.Generic.List)); + + UnityEngine.CanvasRenderer.SplitUIVertexStreams( _verts, _positions, _colors, _uv0S, _uv1S, _uv2S, _uv3S, _normals, _tangents, _indices ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.CanvasRenderer.SplitUIVertexStreams!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CreateUIVertexStream_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 8&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& translator.Assignable>(L, 3)&& translator.Assignable>(L, 4)&& translator.Assignable>(L, 5)&& translator.Assignable>(L, 6)&& translator.Assignable>(L, 7)&& translator.Assignable>(L, 8)) + { + System.Collections.Generic.List _verts = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _positions = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _colors = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _uv0S = (System.Collections.Generic.List)translator.GetObject(L, 4, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _uv1S = (System.Collections.Generic.List)translator.GetObject(L, 5, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _normals = (System.Collections.Generic.List)translator.GetObject(L, 6, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _tangents = (System.Collections.Generic.List)translator.GetObject(L, 7, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _indices = (System.Collections.Generic.List)translator.GetObject(L, 8, typeof(System.Collections.Generic.List)); + + UnityEngine.CanvasRenderer.CreateUIVertexStream( _verts, _positions, _colors, _uv0S, _uv1S, _normals, _tangents, _indices ); + + + + return 0; + } + if(gen_param_count == 10&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& translator.Assignable>(L, 3)&& translator.Assignable>(L, 4)&& translator.Assignable>(L, 5)&& translator.Assignable>(L, 6)&& translator.Assignable>(L, 7)&& translator.Assignable>(L, 8)&& translator.Assignable>(L, 9)&& translator.Assignable>(L, 10)) + { + System.Collections.Generic.List _verts = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _positions = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _colors = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _uv0S = (System.Collections.Generic.List)translator.GetObject(L, 4, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _uv1S = (System.Collections.Generic.List)translator.GetObject(L, 5, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _uv2S = (System.Collections.Generic.List)translator.GetObject(L, 6, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _uv3S = (System.Collections.Generic.List)translator.GetObject(L, 7, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _normals = (System.Collections.Generic.List)translator.GetObject(L, 8, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _tangents = (System.Collections.Generic.List)translator.GetObject(L, 9, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _indices = (System.Collections.Generic.List)translator.GetObject(L, 10, typeof(System.Collections.Generic.List)); + + UnityEngine.CanvasRenderer.CreateUIVertexStream( _verts, _positions, _colors, _uv0S, _uv1S, _uv2S, _uv3S, _normals, _tangents, _indices ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.CanvasRenderer.CreateUIVertexStream!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddUIVertexStream_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 7&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& translator.Assignable>(L, 3)&& translator.Assignable>(L, 4)&& translator.Assignable>(L, 5)&& translator.Assignable>(L, 6)&& translator.Assignable>(L, 7)) + { + System.Collections.Generic.List _verts = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _positions = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _colors = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _uv0S = (System.Collections.Generic.List)translator.GetObject(L, 4, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _uv1S = (System.Collections.Generic.List)translator.GetObject(L, 5, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _normals = (System.Collections.Generic.List)translator.GetObject(L, 6, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _tangents = (System.Collections.Generic.List)translator.GetObject(L, 7, typeof(System.Collections.Generic.List)); + + UnityEngine.CanvasRenderer.AddUIVertexStream( _verts, _positions, _colors, _uv0S, _uv1S, _normals, _tangents ); + + + + return 0; + } + if(gen_param_count == 9&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& translator.Assignable>(L, 3)&& translator.Assignable>(L, 4)&& translator.Assignable>(L, 5)&& translator.Assignable>(L, 6)&& translator.Assignable>(L, 7)&& translator.Assignable>(L, 8)&& translator.Assignable>(L, 9)) + { + System.Collections.Generic.List _verts = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _positions = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _colors = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _uv0S = (System.Collections.Generic.List)translator.GetObject(L, 4, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _uv1S = (System.Collections.Generic.List)translator.GetObject(L, 5, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _uv2S = (System.Collections.Generic.List)translator.GetObject(L, 6, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _uv3S = (System.Collections.Generic.List)translator.GetObject(L, 7, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _normals = (System.Collections.Generic.List)translator.GetObject(L, 8, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _tangents = (System.Collections.Generic.List)translator.GetObject(L, 9, typeof(System.Collections.Generic.List)); + + UnityEngine.CanvasRenderer.AddUIVertexStream( _verts, _positions, _colors, _uv0S, _uv1S, _uv2S, _uv3S, _normals, _tangents ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.CanvasRenderer.AddUIVertexStream!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_hasPopInstruction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hasPopInstruction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_materialCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.materialCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_popMaterialCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.popMaterialCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_absoluteDepth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.absoluteDepth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_hasMoved(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hasMoved); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cullTransparentMesh(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.cullTransparentMesh); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_hasRectClipping(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hasRectClipping); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_relativeDepth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.relativeDepth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cull(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.cull); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_clippingSoftness(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.clippingSoftness); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_hasPopInstruction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.hasPopInstruction = 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_materialCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.materialCount = 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_popMaterialCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.popMaterialCount = 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_cullTransparentMesh(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.cullTransparentMesh = 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_cull(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.cull = 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_clippingSoftness(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.CanvasRenderer gen_to_be_invoked = (UnityEngine.CanvasRenderer)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.clippingSoftness = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_CanvasWrap.cs b/Assets/XLua/Gen/UnityEngine_CanvasWrap.cs new file mode 100644 index 000000000..8b4a5bf3b --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_CanvasWrap.cs @@ -0,0 +1,748 @@ +#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 UnityEngineCanvasWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Canvas); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 20, 14); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "renderMode", _g_get_renderMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isRootCanvas", _g_get_isRootCanvas); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "pixelRect", _g_get_pixelRect); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "scaleFactor", _g_get_scaleFactor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "referencePixelsPerUnit", _g_get_referencePixelsPerUnit); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "overridePixelPerfect", _g_get_overridePixelPerfect); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "pixelPerfect", _g_get_pixelPerfect); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "planeDistance", _g_get_planeDistance); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "renderOrder", _g_get_renderOrder); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "overrideSorting", _g_get_overrideSorting); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sortingOrder", _g_get_sortingOrder); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "targetDisplay", _g_get_targetDisplay); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sortingLayerID", _g_get_sortingLayerID); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "cachedSortingLayerValue", _g_get_cachedSortingLayerValue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "additionalShaderChannels", _g_get_additionalShaderChannels); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sortingLayerName", _g_get_sortingLayerName); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rootCanvas", _g_get_rootCanvas); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "renderingDisplaySize", _g_get_renderingDisplaySize); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "worldCamera", _g_get_worldCamera); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "normalizedSortingGridSize", _g_get_normalizedSortingGridSize); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "renderMode", _s_set_renderMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "scaleFactor", _s_set_scaleFactor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "referencePixelsPerUnit", _s_set_referencePixelsPerUnit); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "overridePixelPerfect", _s_set_overridePixelPerfect); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "pixelPerfect", _s_set_pixelPerfect); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "planeDistance", _s_set_planeDistance); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "overrideSorting", _s_set_overrideSorting); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sortingOrder", _s_set_sortingOrder); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "targetDisplay", _s_set_targetDisplay); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sortingLayerID", _s_set_sortingLayerID); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "additionalShaderChannels", _s_set_additionalShaderChannels); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sortingLayerName", _s_set_sortingLayerName); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "worldCamera", _s_set_worldCamera); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "normalizedSortingGridSize", _s_set_normalizedSortingGridSize); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 6, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetDefaultCanvasMaterial", _m_GetDefaultCanvasMaterial_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetETC1SupportedCanvasMaterial", _m_GetETC1SupportedCanvasMaterial_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ForceUpdateCanvases", _m_ForceUpdateCanvases_xlua_st_); + + Utils.RegisterFunc(L, Utils.CLS_IDX, "preWillRenderCanvases", _e_preWillRenderCanvases); + Utils.RegisterFunc(L, Utils.CLS_IDX, "willRenderCanvases", _e_willRenderCanvases); + + + + + + 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 UnityEngine.Canvas(); + 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 UnityEngine.Canvas constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetDefaultCanvasMaterial_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = UnityEngine.Canvas.GetDefaultCanvasMaterial( ); + 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_GetETC1SupportedCanvasMaterial_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = UnityEngine.Canvas.GetETC1SupportedCanvasMaterial( ); + 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_ForceUpdateCanvases_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + UnityEngine.Canvas.ForceUpdateCanvases( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_renderMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.renderMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isRootCanvas(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isRootCanvas); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_pixelRect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.pixelRect); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_scaleFactor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.scaleFactor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_referencePixelsPerUnit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.referencePixelsPerUnit); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_overridePixelPerfect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.overridePixelPerfect); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_pixelPerfect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.pixelPerfect); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_planeDistance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.planeDistance); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_renderOrder(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.renderOrder); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_overrideSorting(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.overrideSorting); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sortingOrder(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.sortingOrder); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_targetDisplay(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.targetDisplay); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sortingLayerID(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.sortingLayerID); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cachedSortingLayerValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.cachedSortingLayerValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_additionalShaderChannels(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.additionalShaderChannels); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sortingLayerName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.sortingLayerName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rootCanvas(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.rootCanvas); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_renderingDisplaySize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.renderingDisplaySize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_worldCamera(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.worldCamera); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_normalizedSortingGridSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.normalizedSortingGridSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_renderMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + UnityEngine.RenderMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.renderMode = 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_scaleFactor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.scaleFactor = (float)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_referencePixelsPerUnit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.referencePixelsPerUnit = (float)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_overridePixelPerfect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.overridePixelPerfect = 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_pixelPerfect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.pixelPerfect = 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_planeDistance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.planeDistance = (float)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_overrideSorting(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.overrideSorting = 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_sortingOrder(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.sortingOrder = 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_targetDisplay(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.targetDisplay = 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_sortingLayerID(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.sortingLayerID = 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_additionalShaderChannels(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + UnityEngine.AdditionalCanvasShaderChannels gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.additionalShaderChannels = 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_sortingLayerName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.sortingLayerName = 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_worldCamera(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.worldCamera = (UnityEngine.Camera)translator.GetObject(L, 2, typeof(UnityEngine.Camera)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_normalizedSortingGridSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Canvas gen_to_be_invoked = (UnityEngine.Canvas)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.normalizedSortingGridSize = (float)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 _e_preWillRenderCanvases(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + UnityEngine.Canvas.WillRenderCanvases gen_delegate = translator.GetDelegate(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need UnityEngine.Canvas.WillRenderCanvases!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + UnityEngine.Canvas.preWillRenderCanvases += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + UnityEngine.Canvas.preWillRenderCanvases -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Canvas.preWillRenderCanvases!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_willRenderCanvases(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + UnityEngine.Canvas.WillRenderCanvases gen_delegate = translator.GetDelegate(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need UnityEngine.Canvas.WillRenderCanvases!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + UnityEngine.Canvas.willRenderCanvases += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + UnityEngine.Canvas.willRenderCanvases -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Canvas.willRenderCanvases!"); + } + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ColorWrap.cs b/Assets/XLua/Gen/UnityEngine_ColorWrap.cs new file mode 100644 index 000000000..2ee3dbd58 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ColorWrap.cs @@ -0,0 +1,934 @@ +#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 UnityEngineColorWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Color); + Utils.BeginObjectRegister(type, L, translator, 5, 3, 8, 4); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__add", __AddMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__sub", __SubMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__mul", __MulMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__div", __DivMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__eq", __EqMeta); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashCode", _m_GetHashCode); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Equals", _m_Equals); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "grayscale", _g_get_grayscale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "linear", _g_get_linear); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "gamma", _g_get_gamma); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "maxColorComponent", _g_get_maxColorComponent); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "r", _g_get_r); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "g", _g_get_g); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "b", _g_get_b); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "a", _g_get_a); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "r", _s_set_r); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "g", _s_set_g); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "b", _s_set_b); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "a", _s_set_a); + + + Utils.EndObjectRegister(type, L, translator, __CSIndexer, __NewIndexer, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 5, 11, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Lerp", _m_Lerp_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LerpUnclamped", _m_LerpUnclamped_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RGBToHSV", _m_RGBToHSV_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "HSVToRGB", _m_HSVToRGB_xlua_st_); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "red", _g_get_red); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "green", _g_get_green); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "blue", _g_get_blue); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "white", _g_get_white); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "black", _g_get_black); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "yellow", _g_get_yellow); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "cyan", _g_get_cyan); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "magenta", _g_get_magenta); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "gray", _g_get_gray); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "grey", _g_get_grey); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "clear", _g_get_clear); + + + + 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) == 5 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + float _r = (float)LuaAPI.lua_tonumber(L, 2); + float _g = (float)LuaAPI.lua_tonumber(L, 3); + float _b = (float)LuaAPI.lua_tonumber(L, 4); + float _a = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = new UnityEngine.Color(_r, _g, _b, _a); + translator.PushUnityEngineColor(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 4 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _r = (float)LuaAPI.lua_tonumber(L, 2); + float _g = (float)LuaAPI.lua_tonumber(L, 3); + float _b = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = new UnityEngine.Color(_r, _g, _b); + translator.PushUnityEngineColor(L, gen_ret); + + return 1; + } + + if (LuaAPI.lua_gettop(L) == 1) + { + translator.PushUnityEngineColor(L, default(UnityEngine.Color)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Color constructor!"); + + } + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __CSIndexer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + if (translator.Assignable(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + + UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + int index = LuaAPI.xlua_tointeger(L, 2); + LuaAPI.lua_pushboolean(L, true); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked[index]); + return 2; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __NewIndexer(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + try { + + if (translator.Assignable(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + + UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + int key = LuaAPI.xlua_tointeger(L, 2); + gen_to_be_invoked[key] = (float)LuaAPI.lua_tonumber(L, 3); + LuaAPI.lua_pushboolean(L, true); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __AddMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + UnityEngine.Color leftside;translator.Get(L, 1, out leftside); + UnityEngine.Color rightside;translator.Get(L, 2, out rightside); + + translator.PushUnityEngineColor(L, leftside + rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of + operator, need UnityEngine.Color!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __SubMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + UnityEngine.Color leftside;translator.Get(L, 1, out leftside); + UnityEngine.Color rightside;translator.Get(L, 2, out rightside); + + translator.PushUnityEngineColor(L, leftside - rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of - operator, need UnityEngine.Color!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __MulMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + UnityEngine.Color leftside;translator.Get(L, 1, out leftside); + UnityEngine.Color rightside;translator.Get(L, 2, out rightside); + + translator.PushUnityEngineColor(L, leftside * rightside); + + return 1; + } + + + if (translator.Assignable(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + UnityEngine.Color leftside;translator.Get(L, 1, out leftside); + float rightside = (float)LuaAPI.lua_tonumber(L, 2); + + translator.PushUnityEngineColor(L, leftside * rightside); + + return 1; + } + + + if (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) && translator.Assignable(L, 2)) + { + float leftside = (float)LuaAPI.lua_tonumber(L, 1); + UnityEngine.Color rightside;translator.Get(L, 2, out rightside); + + translator.PushUnityEngineColor(L, leftside * rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of * operator, need UnityEngine.Color!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __DivMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + UnityEngine.Color leftside;translator.Get(L, 1, out leftside); + float rightside = (float)LuaAPI.lua_tonumber(L, 2); + + translator.PushUnityEngineColor(L, leftside / rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of / operator, need UnityEngine.Color!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __EqMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + UnityEngine.Color leftside;translator.Get(L, 1, out leftside); + UnityEngine.Color rightside;translator.Get(L, 2, out rightside); + + LuaAPI.lua_pushboolean(L, leftside == rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of == operator, need UnityEngine.Color!"); + + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.ToString( ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.UpdateUnityEngineColor(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _format = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.ToString( _format ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.UpdateUnityEngineColor(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _format = LuaAPI.lua_tostring(L, 2); + System.IFormatProvider _formatProvider = (System.IFormatProvider)translator.GetObject(L, 3, typeof(System.IFormatProvider)); + + var gen_ret = gen_to_be_invoked.ToString( _format, _formatProvider ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.UpdateUnityEngineColor(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Color.ToString!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetHashCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.GetHashCode( ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + translator.UpdateUnityEngineColor(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Equals(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _other = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.Equals( _other ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.UpdateUnityEngineColor(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Color _other;translator.Get(L, 2, out _other); + + var gen_ret = gen_to_be_invoked.Equals( _other ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.UpdateUnityEngineColor(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Color.Equals!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Lerp_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Color _a;translator.Get(L, 1, out _a); + UnityEngine.Color _b;translator.Get(L, 2, out _b); + float _t = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Color.Lerp( _a, _b, _t ); + translator.PushUnityEngineColor(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_LerpUnclamped_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Color _a;translator.Get(L, 1, out _a); + UnityEngine.Color _b;translator.Get(L, 2, out _b); + float _t = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Color.LerpUnclamped( _a, _b, _t ); + translator.PushUnityEngineColor(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_RGBToHSV_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Color _rgbColor;translator.Get(L, 1, out _rgbColor); + float _H; + float _S; + float _V; + + UnityEngine.Color.RGBToHSV( _rgbColor, out _H, out _S, out _V ); + LuaAPI.lua_pushnumber(L, _H); + + LuaAPI.lua_pushnumber(L, _S); + + LuaAPI.lua_pushnumber(L, _V); + + + + + return 3; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HSVToRGB_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _H = (float)LuaAPI.lua_tonumber(L, 1); + float _S = (float)LuaAPI.lua_tonumber(L, 2); + float _V = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Color.HSVToRGB( _H, _S, _V ); + translator.PushUnityEngineColor(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + float _H = (float)LuaAPI.lua_tonumber(L, 1); + float _S = (float)LuaAPI.lua_tonumber(L, 2); + float _V = (float)LuaAPI.lua_tonumber(L, 3); + bool _hdr = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = UnityEngine.Color.HSVToRGB( _H, _S, _V, _hdr ); + translator.PushUnityEngineColor(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 UnityEngine.Color.HSVToRGB!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_red(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineColor(L, UnityEngine.Color.red); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_green(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineColor(L, UnityEngine.Color.green); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_blue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineColor(L, UnityEngine.Color.blue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_white(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineColor(L, UnityEngine.Color.white); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_black(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineColor(L, UnityEngine.Color.black); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_yellow(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineColor(L, UnityEngine.Color.yellow); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cyan(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineColor(L, UnityEngine.Color.cyan); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_magenta(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineColor(L, UnityEngine.Color.magenta); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_gray(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineColor(L, UnityEngine.Color.gray); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_grey(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineColor(L, UnityEngine.Color.grey); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_clear(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineColor(L, UnityEngine.Color.clear); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_grayscale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.grayscale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_linear(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineColor(L, gen_to_be_invoked.linear); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_gamma(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineColor(L, gen_to_be_invoked.gamma); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxColorComponent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.maxColorComponent); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_r(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.r); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_g(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.g); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_b(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.b); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_a(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.a); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_r(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.r = (float)LuaAPI.lua_tonumber(L, 2); + + translator.UpdateUnityEngineColor(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_g(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.g = (float)LuaAPI.lua_tonumber(L, 2); + + translator.UpdateUnityEngineColor(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_b(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.b = (float)LuaAPI.lua_tonumber(L, 2); + + translator.UpdateUnityEngineColor(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_a(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Color gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.a = (float)LuaAPI.lua_tonumber(L, 2); + + translator.UpdateUnityEngineColor(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ComponentWrap.cs b/Assets/XLua/Gen/UnityEngine_ComponentWrap.cs new file mode 100644 index 000000000..898dfdc44 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ComponentWrap.cs @@ -0,0 +1,1108 @@ +#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; +using DG.Tweening; + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class UnityEngineComponentWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Component); + Utils.BeginObjectRegister(type, L, translator, 0, 23, 3, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetComponent", _m_GetComponent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryGetComponent", _m_TryGetComponent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetComponentInChildren", _m_GetComponentInChildren); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetComponentsInChildren", _m_GetComponentsInChildren); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetComponentInParent", _m_GetComponentInParent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetComponentsInParent", _m_GetComponentsInParent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetComponents", _m_GetComponents); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CompareTag", _m_CompareTag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SendMessageUpwards", _m_SendMessageUpwards); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SendMessage", _m_SendMessage); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "BroadcastMessage", _m_BroadcastMessage); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOComplete", _m_DOComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOKill", _m_DOKill); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOFlip", _m_DOFlip); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOGoto", _m_DOGoto); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOPause", _m_DOPause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOPlay", _m_DOPlay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOPlayBackwards", _m_DOPlayBackwards); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOPlayForward", _m_DOPlayForward); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DORestart", _m_DORestart); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DORewind", _m_DORewind); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOSmoothRewind", _m_DOSmoothRewind); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOTogglePause", _m_DOTogglePause); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "transform", _g_get_transform); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "gameObject", _g_get_gameObject); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "tag", _g_get_tag); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "tag", _s_set_tag); + + + 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 UnityEngine.Component(); + 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 UnityEngine.Component constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetComponent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Component gen_to_be_invoked = (UnityEngine.Component)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.Type _type = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + + var gen_ret = gen_to_be_invoked.GetComponent( _type ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _type = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetComponent( _type ); + 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 UnityEngine.Component.GetComponent!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TryGetComponent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Component gen_to_be_invoked = (UnityEngine.Component)translator.FastGetCSObj(L, 1); + + + + { + System.Type _type = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + UnityEngine.Component _component; + + var gen_ret = gen_to_be_invoked.TryGetComponent( _type, out _component ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _component); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetComponentInChildren(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Component gen_to_be_invoked = (UnityEngine.Component)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.Type _t = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + + var gen_ret = gen_to_be_invoked.GetComponentInChildren( _t ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + System.Type _t = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + bool _includeInactive = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.GetComponentInChildren( _t, _includeInactive ); + 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 UnityEngine.Component.GetComponentInChildren!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetComponentsInChildren(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Component gen_to_be_invoked = (UnityEngine.Component)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.Type _t = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + + var gen_ret = gen_to_be_invoked.GetComponentsInChildren( _t ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + System.Type _t = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + bool _includeInactive = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.GetComponentsInChildren( _t, _includeInactive ); + 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 UnityEngine.Component.GetComponentsInChildren!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetComponentInParent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Component gen_to_be_invoked = (UnityEngine.Component)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.Type _t = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + + var gen_ret = gen_to_be_invoked.GetComponentInParent( _t ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + System.Type _t = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + bool _includeInactive = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.GetComponentInParent( _t, _includeInactive ); + 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 UnityEngine.Component.GetComponentInParent!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetComponentsInParent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Component gen_to_be_invoked = (UnityEngine.Component)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.Type _t = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + + var gen_ret = gen_to_be_invoked.GetComponentsInParent( _t ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + System.Type _t = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + bool _includeInactive = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.GetComponentsInParent( _t, _includeInactive ); + 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 UnityEngine.Component.GetComponentsInParent!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetComponents(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Component gen_to_be_invoked = (UnityEngine.Component)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.Type _type = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + + var gen_ret = gen_to_be_invoked.GetComponents( _type ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable>(L, 3)) + { + System.Type _type = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + System.Collections.Generic.List _results = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetComponents( _type, _results ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Component.GetComponents!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CompareTag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Component gen_to_be_invoked = (UnityEngine.Component)translator.FastGetCSObj(L, 1); + + + + { + string _tag = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.CompareTag( _tag ); + 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_SendMessageUpwards(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Component gen_to_be_invoked = (UnityEngine.Component)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _methodName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SendMessageUpwards( _methodName ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _methodName = LuaAPI.lua_tostring(L, 2); + object _value = translator.GetObject(L, 3, typeof(object)); + + gen_to_be_invoked.SendMessageUpwards( _methodName, _value ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _methodName = LuaAPI.lua_tostring(L, 2); + UnityEngine.SendMessageOptions _options;translator.Get(L, 3, out _options); + + gen_to_be_invoked.SendMessageUpwards( _methodName, _options ); + + + + return 0; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + string _methodName = LuaAPI.lua_tostring(L, 2); + object _value = translator.GetObject(L, 3, typeof(object)); + UnityEngine.SendMessageOptions _options;translator.Get(L, 4, out _options); + + gen_to_be_invoked.SendMessageUpwards( _methodName, _value, _options ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Component.SendMessageUpwards!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SendMessage(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Component gen_to_be_invoked = (UnityEngine.Component)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _methodName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SendMessage( _methodName ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _methodName = LuaAPI.lua_tostring(L, 2); + object _value = translator.GetObject(L, 3, typeof(object)); + + gen_to_be_invoked.SendMessage( _methodName, _value ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _methodName = LuaAPI.lua_tostring(L, 2); + UnityEngine.SendMessageOptions _options;translator.Get(L, 3, out _options); + + gen_to_be_invoked.SendMessage( _methodName, _options ); + + + + return 0; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + string _methodName = LuaAPI.lua_tostring(L, 2); + object _value = translator.GetObject(L, 3, typeof(object)); + UnityEngine.SendMessageOptions _options;translator.Get(L, 4, out _options); + + gen_to_be_invoked.SendMessage( _methodName, _value, _options ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Component.SendMessage!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_BroadcastMessage(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Component gen_to_be_invoked = (UnityEngine.Component)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _methodName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.BroadcastMessage( _methodName ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _methodName = LuaAPI.lua_tostring(L, 2); + object _parameter = translator.GetObject(L, 3, typeof(object)); + + gen_to_be_invoked.BroadcastMessage( _methodName, _parameter ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _methodName = LuaAPI.lua_tostring(L, 2); + UnityEngine.SendMessageOptions _options;translator.Get(L, 3, out _options); + + gen_to_be_invoked.BroadcastMessage( _methodName, _options ); + + + + return 0; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + string _methodName = LuaAPI.lua_tostring(L, 2); + object _parameter = translator.GetObject(L, 3, typeof(object)); + UnityEngine.SendMessageOptions _options;translator.Get(L, 4, out _options); + + gen_to_be_invoked.BroadcastMessage( _methodName, _parameter, _options ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Component.BroadcastMessage!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Component gen_to_be_invoked = (UnityEngine.Component)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _withCallbacks = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.DOComplete( _withCallbacks ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.DOComplete( ); + LuaAPI.xlua_pushinteger(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 UnityEngine.Component.DOComplete!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOKill(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Component gen_to_be_invoked = (UnityEngine.Component)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _complete = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.DOKill( _complete ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.DOKill( ); + LuaAPI.xlua_pushinteger(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 UnityEngine.Component.DOKill!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOFlip(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Component gen_to_be_invoked = (UnityEngine.Component)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.DOFlip( ); + 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_DOGoto(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Component gen_to_be_invoked = (UnityEngine.Component)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + float _to = (float)LuaAPI.lua_tonumber(L, 2); + bool _andPlay = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.DOGoto( _to, _andPlay ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _to = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.DOGoto( _to ); + LuaAPI.xlua_pushinteger(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 UnityEngine.Component.DOGoto!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOPause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Component gen_to_be_invoked = (UnityEngine.Component)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.DOPause( ); + 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_DOPlay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Component gen_to_be_invoked = (UnityEngine.Component)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.DOPlay( ); + 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_DOPlayBackwards(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Component gen_to_be_invoked = (UnityEngine.Component)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.DOPlayBackwards( ); + 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_DOPlayForward(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Component gen_to_be_invoked = (UnityEngine.Component)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.DOPlayForward( ); + 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_DORestart(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Component gen_to_be_invoked = (UnityEngine.Component)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _includeDelay = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.DORestart( _includeDelay ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.DORestart( ); + LuaAPI.xlua_pushinteger(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 UnityEngine.Component.DORestart!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DORewind(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Component gen_to_be_invoked = (UnityEngine.Component)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _includeDelay = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.DORewind( _includeDelay ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.DORewind( ); + LuaAPI.xlua_pushinteger(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 UnityEngine.Component.DORewind!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOSmoothRewind(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Component gen_to_be_invoked = (UnityEngine.Component)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.DOSmoothRewind( ); + 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_DOTogglePause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Component gen_to_be_invoked = (UnityEngine.Component)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.DOTogglePause( ); + 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 _g_get_transform(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Component gen_to_be_invoked = (UnityEngine.Component)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.transform); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_gameObject(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Component gen_to_be_invoked = (UnityEngine.Component)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.gameObject); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_tag(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Component gen_to_be_invoked = (UnityEngine.Component)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.tag); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_tag(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Component gen_to_be_invoked = (UnityEngine.Component)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.tag = 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/UnityEngine_DebugWrap.cs b/Assets/XLua/Gen/UnityEngine_DebugWrap.cs new file mode 100644 index 000000000..dd05f0191 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_DebugWrap.cs @@ -0,0 +1,885 @@ +#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 UnityEngineDebugWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Debug); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 17, 3, 1); + Utils.RegisterFunc(L, Utils.CLS_IDX, "DrawLine", _m_DrawLine_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "DrawRay", _m_DrawRay_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Break", _m_Break_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "DebugBreak", _m_DebugBreak_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Log", _m_Log_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LogFormat", _m_LogFormat_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LogError", _m_LogError_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LogErrorFormat", _m_LogErrorFormat_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ClearDeveloperConsole", _m_ClearDeveloperConsole_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LogException", _m_LogException_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LogWarning", _m_LogWarning_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LogWarningFormat", _m_LogWarningFormat_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Assert", _m_Assert_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "AssertFormat", _m_AssertFormat_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LogAssertion", _m_LogAssertion_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LogAssertionFormat", _m_LogAssertionFormat_xlua_st_); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "unityLogger", _g_get_unityLogger); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "developerConsoleVisible", _g_get_developerConsoleVisible); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "isDebugBuild", _g_get_isDebugBuild); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "developerConsoleVisible", _s_set_developerConsoleVisible); + + + 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 UnityEngine.Debug(); + 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 UnityEngine.Debug constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DrawLine_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _start;translator.Get(L, 1, out _start); + UnityEngine.Vector3 _end;translator.Get(L, 2, out _end); + + UnityEngine.Debug.DrawLine( _start, _end ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _start;translator.Get(L, 1, out _start); + UnityEngine.Vector3 _end;translator.Get(L, 2, out _end); + UnityEngine.Color _color;translator.Get(L, 3, out _color); + + UnityEngine.Debug.DrawLine( _start, _end, _color ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3 _start;translator.Get(L, 1, out _start); + UnityEngine.Vector3 _end;translator.Get(L, 2, out _end); + UnityEngine.Color _color;translator.Get(L, 3, out _color); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + UnityEngine.Debug.DrawLine( _start, _end, _color, _duration ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Vector3 _start;translator.Get(L, 1, out _start); + UnityEngine.Vector3 _end;translator.Get(L, 2, out _end); + UnityEngine.Color _color;translator.Get(L, 3, out _color); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + bool _depthTest = LuaAPI.lua_toboolean(L, 5); + + UnityEngine.Debug.DrawLine( _start, _end, _color, _duration, _depthTest ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Debug.DrawLine!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DrawRay_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _start;translator.Get(L, 1, out _start); + UnityEngine.Vector3 _dir;translator.Get(L, 2, out _dir); + + UnityEngine.Debug.DrawRay( _start, _dir ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _start;translator.Get(L, 1, out _start); + UnityEngine.Vector3 _dir;translator.Get(L, 2, out _dir); + UnityEngine.Color _color;translator.Get(L, 3, out _color); + + UnityEngine.Debug.DrawRay( _start, _dir, _color ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3 _start;translator.Get(L, 1, out _start); + UnityEngine.Vector3 _dir;translator.Get(L, 2, out _dir); + UnityEngine.Color _color;translator.Get(L, 3, out _color); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + UnityEngine.Debug.DrawRay( _start, _dir, _color, _duration ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Vector3 _start;translator.Get(L, 1, out _start); + UnityEngine.Vector3 _dir;translator.Get(L, 2, out _dir); + UnityEngine.Color _color;translator.Get(L, 3, out _color); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + bool _depthTest = LuaAPI.lua_toboolean(L, 5); + + UnityEngine.Debug.DrawRay( _start, _dir, _color, _duration, _depthTest ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Debug.DrawRay!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Break_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + UnityEngine.Debug.Break( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DebugBreak_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + UnityEngine.Debug.DebugBreak( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Log_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _message = translator.GetObject(L, 1, typeof(object)); + + UnityEngine.Debug.Log( _message ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + object _message = translator.GetObject(L, 1, typeof(object)); + UnityEngine.Object _context = (UnityEngine.Object)translator.GetObject(L, 2, typeof(UnityEngine.Object)); + + UnityEngine.Debug.Log( _message, _context ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Debug.Log!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LogFormat_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)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 2) || translator.Assignable(L, 2))) + { + string _format = LuaAPI.lua_tostring(L, 1); + object[] _args = translator.GetParams(L, 2); + + UnityEngine.Debug.LogFormat( _format, _args ); + + + + return 0; + } + if(gen_param_count >= 2&& translator.Assignable(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 3) || translator.Assignable(L, 3))) + { + UnityEngine.Object _context = (UnityEngine.Object)translator.GetObject(L, 1, typeof(UnityEngine.Object)); + string _format = LuaAPI.lua_tostring(L, 2); + object[] _args = translator.GetParams(L, 3); + + UnityEngine.Debug.LogFormat( _context, _format, _args ); + + + + return 0; + } + if(gen_param_count >= 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 5) || translator.Assignable(L, 5))) + { + UnityEngine.LogType _logType;translator.Get(L, 1, out _logType); + UnityEngine.LogOption _logOptions;translator.Get(L, 2, out _logOptions); + UnityEngine.Object _context = (UnityEngine.Object)translator.GetObject(L, 3, typeof(UnityEngine.Object)); + string _format = LuaAPI.lua_tostring(L, 4); + object[] _args = translator.GetParams(L, 5); + + UnityEngine.Debug.LogFormat( _logType, _logOptions, _context, _format, _args ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Debug.LogFormat!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LogError_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _message = translator.GetObject(L, 1, typeof(object)); + + UnityEngine.Debug.LogError( _message ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + object _message = translator.GetObject(L, 1, typeof(object)); + UnityEngine.Object _context = (UnityEngine.Object)translator.GetObject(L, 2, typeof(UnityEngine.Object)); + + UnityEngine.Debug.LogError( _message, _context ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Debug.LogError!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LogErrorFormat_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)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 2) || translator.Assignable(L, 2))) + { + string _format = LuaAPI.lua_tostring(L, 1); + object[] _args = translator.GetParams(L, 2); + + UnityEngine.Debug.LogErrorFormat( _format, _args ); + + + + return 0; + } + if(gen_param_count >= 2&& translator.Assignable(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 3) || translator.Assignable(L, 3))) + { + UnityEngine.Object _context = (UnityEngine.Object)translator.GetObject(L, 1, typeof(UnityEngine.Object)); + string _format = LuaAPI.lua_tostring(L, 2); + object[] _args = translator.GetParams(L, 3); + + UnityEngine.Debug.LogErrorFormat( _context, _format, _args ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Debug.LogErrorFormat!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearDeveloperConsole_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + UnityEngine.Debug.ClearDeveloperConsole( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LogException_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + System.Exception _exception = (System.Exception)translator.GetObject(L, 1, typeof(System.Exception)); + + UnityEngine.Debug.LogException( _exception ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + System.Exception _exception = (System.Exception)translator.GetObject(L, 1, typeof(System.Exception)); + UnityEngine.Object _context = (UnityEngine.Object)translator.GetObject(L, 2, typeof(UnityEngine.Object)); + + UnityEngine.Debug.LogException( _exception, _context ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Debug.LogException!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LogWarning_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _message = translator.GetObject(L, 1, typeof(object)); + + UnityEngine.Debug.LogWarning( _message ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + object _message = translator.GetObject(L, 1, typeof(object)); + UnityEngine.Object _context = (UnityEngine.Object)translator.GetObject(L, 2, typeof(UnityEngine.Object)); + + UnityEngine.Debug.LogWarning( _message, _context ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Debug.LogWarning!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LogWarningFormat_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)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 2) || translator.Assignable(L, 2))) + { + string _format = LuaAPI.lua_tostring(L, 1); + object[] _args = translator.GetParams(L, 2); + + UnityEngine.Debug.LogWarningFormat( _format, _args ); + + + + return 0; + } + if(gen_param_count >= 2&& translator.Assignable(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 3) || translator.Assignable(L, 3))) + { + UnityEngine.Object _context = (UnityEngine.Object)translator.GetObject(L, 1, typeof(UnityEngine.Object)); + string _format = LuaAPI.lua_tostring(L, 2); + object[] _args = translator.GetParams(L, 3); + + UnityEngine.Debug.LogWarningFormat( _context, _format, _args ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Debug.LogWarningFormat!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Assert_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)) + { + bool _condition = LuaAPI.lua_toboolean(L, 1); + + UnityEngine.Debug.Assert( _condition ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + bool _condition = LuaAPI.lua_toboolean(L, 1); + UnityEngine.Object _context = (UnityEngine.Object)translator.GetObject(L, 2, typeof(UnityEngine.Object)); + + UnityEngine.Debug.Assert( _condition, _context ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + bool _condition = LuaAPI.lua_toboolean(L, 1); + object _message = translator.GetObject(L, 2, typeof(object)); + + UnityEngine.Debug.Assert( _condition, _message ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + bool _condition = LuaAPI.lua_toboolean(L, 1); + string _message = LuaAPI.lua_tostring(L, 2); + + UnityEngine.Debug.Assert( _condition, _message ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + bool _condition = LuaAPI.lua_toboolean(L, 1); + object _message = translator.GetObject(L, 2, typeof(object)); + UnityEngine.Object _context = (UnityEngine.Object)translator.GetObject(L, 3, typeof(UnityEngine.Object)); + + UnityEngine.Debug.Assert( _condition, _message, _context ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + bool _condition = LuaAPI.lua_toboolean(L, 1); + string _message = LuaAPI.lua_tostring(L, 2); + UnityEngine.Object _context = (UnityEngine.Object)translator.GetObject(L, 3, typeof(UnityEngine.Object)); + + UnityEngine.Debug.Assert( _condition, _message, _context ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Debug.Assert!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AssertFormat_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count >= 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 3) || translator.Assignable(L, 3))) + { + bool _condition = LuaAPI.lua_toboolean(L, 1); + string _format = LuaAPI.lua_tostring(L, 2); + object[] _args = translator.GetParams(L, 3); + + UnityEngine.Debug.AssertFormat( _condition, _format, _args ); + + + + return 0; + } + if(gen_param_count >= 3&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 4) || translator.Assignable(L, 4))) + { + bool _condition = LuaAPI.lua_toboolean(L, 1); + UnityEngine.Object _context = (UnityEngine.Object)translator.GetObject(L, 2, typeof(UnityEngine.Object)); + string _format = LuaAPI.lua_tostring(L, 3); + object[] _args = translator.GetParams(L, 4); + + UnityEngine.Debug.AssertFormat( _condition, _context, _format, _args ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Debug.AssertFormat!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LogAssertion_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + object _message = translator.GetObject(L, 1, typeof(object)); + + UnityEngine.Debug.LogAssertion( _message ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + object _message = translator.GetObject(L, 1, typeof(object)); + UnityEngine.Object _context = (UnityEngine.Object)translator.GetObject(L, 2, typeof(UnityEngine.Object)); + + UnityEngine.Debug.LogAssertion( _message, _context ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Debug.LogAssertion!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LogAssertionFormat_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)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 2) || translator.Assignable(L, 2))) + { + string _format = LuaAPI.lua_tostring(L, 1); + object[] _args = translator.GetParams(L, 2); + + UnityEngine.Debug.LogAssertionFormat( _format, _args ); + + + + return 0; + } + if(gen_param_count >= 2&& translator.Assignable(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 3) || translator.Assignable(L, 3))) + { + UnityEngine.Object _context = (UnityEngine.Object)translator.GetObject(L, 1, typeof(UnityEngine.Object)); + string _format = LuaAPI.lua_tostring(L, 2); + object[] _args = translator.GetParams(L, 3); + + UnityEngine.Debug.LogAssertionFormat( _context, _format, _args ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Debug.LogAssertionFormat!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_unityLogger(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushAny(L, UnityEngine.Debug.unityLogger); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_developerConsoleVisible(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Debug.developerConsoleVisible); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isDebugBuild(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Debug.isDebugBuild); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_developerConsoleVisible(RealStatePtr L) + { + try { + + UnityEngine.Debug.developerConsoleVisible = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_EventSystems_UIBehaviourWrap.cs b/Assets/XLua/Gen/UnityEngine_EventSystems_UIBehaviourWrap.cs new file mode 100644 index 000000000..4a7836038 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_EventSystems_UIBehaviourWrap.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 UnityEngineEventSystemsUIBehaviourWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.EventSystems.UIBehaviour); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsActive", _m_IsActive); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsDestroyed", _m_IsDestroyed); + + + + + + 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, "UnityEngine.EventSystems.UIBehaviour does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsActive(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.EventSystems.UIBehaviour gen_to_be_invoked = (UnityEngine.EventSystems.UIBehaviour)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsActive( ); + 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_IsDestroyed(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.EventSystems.UIBehaviour gen_to_be_invoked = (UnityEngine.EventSystems.UIBehaviour)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsDestroyed( ); + LuaAPI.lua_pushboolean(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/UnityEngine_Events_UnityEventBaseWrap.cs b/Assets/XLua/Gen/UnityEngine_Events_UnityEventBaseWrap.cs new file mode 100644 index 000000000..cc9c27eb5 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_Events_UnityEventBaseWrap.cs @@ -0,0 +1,320 @@ +#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 UnityEngineEventsUnityEventBaseWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Events.UnityEventBase); + Utils.BeginObjectRegister(type, L, translator, 0, 7, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPersistentEventCount", _m_GetPersistentEventCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPersistentTarget", _m_GetPersistentTarget); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPersistentMethodName", _m_GetPersistentMethodName); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPersistentListenerState", _m_SetPersistentListenerState); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPersistentListenerState", _m_GetPersistentListenerState); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveAllListeners", _m_RemoveAllListeners); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetValidMethodInfo", _m_GetValidMethodInfo_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "UnityEngine.Events.UnityEventBase does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetPersistentEventCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Events.UnityEventBase gen_to_be_invoked = (UnityEngine.Events.UnityEventBase)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetPersistentEventCount( ); + 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_GetPersistentTarget(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Events.UnityEventBase gen_to_be_invoked = (UnityEngine.Events.UnityEventBase)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetPersistentTarget( _index ); + 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_GetPersistentMethodName(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Events.UnityEventBase gen_to_be_invoked = (UnityEngine.Events.UnityEventBase)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetPersistentMethodName( _index ); + 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 _m_SetPersistentListenerState(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Events.UnityEventBase gen_to_be_invoked = (UnityEngine.Events.UnityEventBase)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Events.UnityEventCallState _state;translator.Get(L, 3, out _state); + + gen_to_be_invoked.SetPersistentListenerState( _index, _state ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetPersistentListenerState(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Events.UnityEventBase gen_to_be_invoked = (UnityEngine.Events.UnityEventBase)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetPersistentListenerState( _index ); + 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_RemoveAllListeners(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Events.UnityEventBase gen_to_be_invoked = (UnityEngine.Events.UnityEventBase)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RemoveAllListeners( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Events.UnityEventBase gen_to_be_invoked = (UnityEngine.Events.UnityEventBase)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 _m_GetValidMethodInfo_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + object _obj = translator.GetObject(L, 1, typeof(object)); + string _functionName = LuaAPI.lua_tostring(L, 2); + System.Type[] _argumentTypes = (System.Type[])translator.GetObject(L, 3, typeof(System.Type[])); + + var gen_ret = UnityEngine.Events.UnityEventBase.GetValidMethodInfo( _obj, _functionName, _argumentTypes ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + System.Type _objectType = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + string _functionName = LuaAPI.lua_tostring(L, 2); + System.Type[] _argumentTypes = (System.Type[])translator.GetObject(L, 3, typeof(System.Type[])); + + var gen_ret = UnityEngine.Events.UnityEventBase.GetValidMethodInfo( _objectType, _functionName, _argumentTypes ); + 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 UnityEngine.Events.UnityEventBase.GetValidMethodInfo!"); + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_Events_UnityEventWrap.cs b/Assets/XLua/Gen/UnityEngine_Events_UnityEventWrap.cs new file mode 100644 index 000000000..1eef1538d --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_Events_UnityEventWrap.cs @@ -0,0 +1,170 @@ +#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 UnityEngineEventsUnityEventWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Events.UnityEvent); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddListener", _m_AddListener); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveListener", _m_RemoveListener); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Invoke", _m_Invoke); + + + + + + 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 UnityEngine.Events.UnityEvent(); + 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 UnityEngine.Events.UnityEvent constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddListener(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Events.UnityEvent gen_to_be_invoked = (UnityEngine.Events.UnityEvent)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Events.UnityAction _call = translator.GetDelegate(L, 2); + + gen_to_be_invoked.AddListener( _call ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveListener(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Events.UnityEvent gen_to_be_invoked = (UnityEngine.Events.UnityEvent)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Events.UnityAction _call = translator.GetDelegate(L, 2); + + gen_to_be_invoked.RemoveListener( _call ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Invoke(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Events.UnityEvent gen_to_be_invoked = (UnityEngine.Events.UnityEvent)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Invoke( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_Events_UnityEvent_1_System_Int32_Wrap.cs b/Assets/XLua/Gen/UnityEngine_Events_UnityEvent_1_System_Int32_Wrap.cs new file mode 100644 index 000000000..8623db9b2 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_Events_UnityEvent_1_System_Int32_Wrap.cs @@ -0,0 +1,171 @@ +#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 UnityEngineEventsUnityEvent_1_SystemInt32_Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Events.UnityEvent); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddListener", _m_AddListener); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveListener", _m_RemoveListener); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Invoke", _m_Invoke); + + + + + + 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 UnityEngine.Events.UnityEvent(); + 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 UnityEngine.Events.UnityEvent constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddListener(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Events.UnityEvent gen_to_be_invoked = (UnityEngine.Events.UnityEvent)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Events.UnityAction _call = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.AddListener( _call ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveListener(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Events.UnityEvent gen_to_be_invoked = (UnityEngine.Events.UnityEvent)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Events.UnityAction _call = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.RemoveListener( _call ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Invoke(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Events.UnityEvent gen_to_be_invoked = (UnityEngine.Events.UnityEvent)translator.FastGetCSObj(L, 1); + + + + { + int _arg0 = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.Invoke( _arg0 ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_Events_UnityEvent_1_System_Int64_Wrap.cs b/Assets/XLua/Gen/UnityEngine_Events_UnityEvent_1_System_Int64_Wrap.cs new file mode 100644 index 000000000..f59b5d4cf --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_Events_UnityEvent_1_System_Int64_Wrap.cs @@ -0,0 +1,171 @@ +#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 UnityEngineEventsUnityEvent_1_SystemInt64_Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Events.UnityEvent); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddListener", _m_AddListener); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveListener", _m_RemoveListener); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Invoke", _m_Invoke); + + + + + + 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 UnityEngine.Events.UnityEvent(); + 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 UnityEngine.Events.UnityEvent constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddListener(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Events.UnityEvent gen_to_be_invoked = (UnityEngine.Events.UnityEvent)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Events.UnityAction _call = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.AddListener( _call ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveListener(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Events.UnityEvent gen_to_be_invoked = (UnityEngine.Events.UnityEvent)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Events.UnityAction _call = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.RemoveListener( _call ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Invoke(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Events.UnityEvent gen_to_be_invoked = (UnityEngine.Events.UnityEvent)translator.FastGetCSObj(L, 1); + + + + { + long _arg0 = LuaAPI.lua_toint64(L, 2); + + gen_to_be_invoked.Invoke( _arg0 ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_Events_UnityEvent_1_System_Single_Wrap.cs b/Assets/XLua/Gen/UnityEngine_Events_UnityEvent_1_System_Single_Wrap.cs new file mode 100644 index 000000000..3ccd5b1c2 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_Events_UnityEvent_1_System_Single_Wrap.cs @@ -0,0 +1,171 @@ +#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 UnityEngineEventsUnityEvent_1_SystemSingle_Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Events.UnityEvent); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddListener", _m_AddListener); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveListener", _m_RemoveListener); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Invoke", _m_Invoke); + + + + + + 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 UnityEngine.Events.UnityEvent(); + 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 UnityEngine.Events.UnityEvent constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddListener(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Events.UnityEvent gen_to_be_invoked = (UnityEngine.Events.UnityEvent)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Events.UnityAction _call = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.AddListener( _call ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveListener(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Events.UnityEvent gen_to_be_invoked = (UnityEngine.Events.UnityEvent)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Events.UnityAction _call = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.RemoveListener( _call ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Invoke(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Events.UnityEvent gen_to_be_invoked = (UnityEngine.Events.UnityEvent)translator.FastGetCSObj(L, 1); + + + + { + float _arg0 = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.Invoke( _arg0 ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_Events_UnityEvent_1_System_String_Wrap.cs b/Assets/XLua/Gen/UnityEngine_Events_UnityEvent_1_System_String_Wrap.cs new file mode 100644 index 000000000..0dafcdefe --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_Events_UnityEvent_1_System_String_Wrap.cs @@ -0,0 +1,171 @@ +#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 UnityEngineEventsUnityEvent_1_SystemString_Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Events.UnityEvent); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddListener", _m_AddListener); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveListener", _m_RemoveListener); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Invoke", _m_Invoke); + + + + + + 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 UnityEngine.Events.UnityEvent(); + 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 UnityEngine.Events.UnityEvent constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddListener(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Events.UnityEvent gen_to_be_invoked = (UnityEngine.Events.UnityEvent)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Events.UnityAction _call = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.AddListener( _call ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveListener(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Events.UnityEvent gen_to_be_invoked = (UnityEngine.Events.UnityEvent)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Events.UnityAction _call = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.RemoveListener( _call ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Invoke(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Events.UnityEvent gen_to_be_invoked = (UnityEngine.Events.UnityEvent)translator.FastGetCSObj(L, 1); + + + + { + string _arg0 = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.Invoke( _arg0 ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_Events_UnityEvent_1_UnityEngine_Vector2_Wrap.cs b/Assets/XLua/Gen/UnityEngine_Events_UnityEvent_1_UnityEngine_Vector2_Wrap.cs new file mode 100644 index 000000000..7bd7f46bb --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_Events_UnityEvent_1_UnityEngine_Vector2_Wrap.cs @@ -0,0 +1,171 @@ +#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 UnityEngineEventsUnityEvent_1_UnityEngineVector2_Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Events.UnityEvent); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddListener", _m_AddListener); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveListener", _m_RemoveListener); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Invoke", _m_Invoke); + + + + + + 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 UnityEngine.Events.UnityEvent(); + 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 UnityEngine.Events.UnityEvent constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddListener(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Events.UnityEvent gen_to_be_invoked = (UnityEngine.Events.UnityEvent)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Events.UnityAction _call = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.AddListener( _call ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveListener(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Events.UnityEvent gen_to_be_invoked = (UnityEngine.Events.UnityEvent)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Events.UnityAction _call = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.RemoveListener( _call ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Invoke(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Events.UnityEvent gen_to_be_invoked = (UnityEngine.Events.UnityEvent)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector2 _arg0;translator.Get(L, 2, out _arg0); + + gen_to_be_invoked.Invoke( _arg0 ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_FontWrap.cs b/Assets/XLua/Gen/UnityEngine_FontWrap.cs new file mode 100644 index 000000000..5cc4765bf --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_FontWrap.cs @@ -0,0 +1,555 @@ +#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 UnityEngineFontWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Font); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 7, 3); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasCharacter", _m_HasCharacter); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetCharacterInfo", _m_GetCharacterInfo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RequestCharactersInTexture", _m_RequestCharactersInTexture); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "material", _g_get_material); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fontNames", _g_get_fontNames); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "dynamic", _g_get_dynamic); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ascent", _g_get_ascent); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fontSize", _g_get_fontSize); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "characterInfo", _g_get_characterInfo); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lineHeight", _g_get_lineHeight); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "material", _s_set_material); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fontNames", _s_set_fontNames); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "characterInfo", _s_set_characterInfo); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 6, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CreateDynamicFontFromOSFont", _m_CreateDynamicFontFromOSFont_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetMaxVertsForString", _m_GetMaxVertsForString_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetOSInstalledFontNames", _m_GetOSInstalledFontNames_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetPathsToOSFonts", _m_GetPathsToOSFonts_xlua_st_); + + Utils.RegisterFunc(L, Utils.CLS_IDX, "textureRebuilt", _e_textureRebuilt); + + + + + + 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 UnityEngine.Font(); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = new UnityEngine.Font(_name); + 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 UnityEngine.Font constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CreateDynamicFontFromOSFont_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + string _fontname = LuaAPI.lua_tostring(L, 1); + int _size = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = UnityEngine.Font.CreateDynamicFontFromOSFont( _fontname, _size ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + string[] _fontnames = (string[])translator.GetObject(L, 1, typeof(string[])); + int _size = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = UnityEngine.Font.CreateDynamicFontFromOSFont( _fontnames, _size ); + 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 UnityEngine.Font.CreateDynamicFontFromOSFont!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetMaxVertsForString_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _str = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.Font.GetMaxVertsForString( _str ); + 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_HasCharacter(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Font gen_to_be_invoked = (UnityEngine.Font)translator.FastGetCSObj(L, 1); + + + + { + char _c = (char)LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.HasCharacter( _c ); + 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_GetOSInstalledFontNames_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = UnityEngine.Font.GetOSInstalledFontNames( ); + 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_GetPathsToOSFonts_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = UnityEngine.Font.GetPathsToOSFonts( ); + 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_GetCharacterInfo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Font gen_to_be_invoked = (UnityEngine.Font)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + char _ch = (char)LuaAPI.xlua_tointeger(L, 2); + UnityEngine.CharacterInfo _info; + + var gen_ret = gen_to_be_invoked.GetCharacterInfo( _ch, out _info ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _info); + + + + + return 2; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + char _ch = (char)LuaAPI.xlua_tointeger(L, 2); + UnityEngine.CharacterInfo _info; + int _size = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.GetCharacterInfo( _ch, out _info, _size ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _info); + + + + + return 2; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + char _ch = (char)LuaAPI.xlua_tointeger(L, 2); + UnityEngine.CharacterInfo _info; + int _size = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.FontStyle _style;translator.Get(L, 4, out _style); + + var gen_ret = gen_to_be_invoked.GetCharacterInfo( _ch, out _info, _size, _style ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _info); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Font.GetCharacterInfo!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RequestCharactersInTexture(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Font gen_to_be_invoked = (UnityEngine.Font)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _characters = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.RequestCharactersInTexture( _characters ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + string _characters = LuaAPI.lua_tostring(L, 2); + int _size = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.RequestCharactersInTexture( _characters, _size ); + + + + return 0; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + string _characters = LuaAPI.lua_tostring(L, 2); + int _size = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.FontStyle _style;translator.Get(L, 4, out _style); + + gen_to_be_invoked.RequestCharactersInTexture( _characters, _size, _style ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Font.RequestCharactersInTexture!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_material(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Font gen_to_be_invoked = (UnityEngine.Font)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.material); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fontNames(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Font gen_to_be_invoked = (UnityEngine.Font)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.fontNames); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_dynamic(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Font gen_to_be_invoked = (UnityEngine.Font)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.dynamic); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ascent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Font gen_to_be_invoked = (UnityEngine.Font)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.ascent); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fontSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Font gen_to_be_invoked = (UnityEngine.Font)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.fontSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_characterInfo(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Font gen_to_be_invoked = (UnityEngine.Font)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.characterInfo); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lineHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Font gen_to_be_invoked = (UnityEngine.Font)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.lineHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_material(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Font gen_to_be_invoked = (UnityEngine.Font)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.material = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_fontNames(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Font gen_to_be_invoked = (UnityEngine.Font)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.fontNames = (string[])translator.GetObject(L, 2, typeof(string[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_characterInfo(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Font gen_to_be_invoked = (UnityEngine.Font)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.characterInfo = (UnityEngine.CharacterInfo[])translator.GetObject(L, 2, typeof(UnityEngine.CharacterInfo[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_textureRebuilt(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + UnityEngine.Font.textureRebuilt += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + UnityEngine.Font.textureRebuilt -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Font.textureRebuilt!"); + } + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_GameObjectWrap.cs b/Assets/XLua/Gen/UnityEngine_GameObjectWrap.cs new file mode 100644 index 000000000..5fe899658 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_GameObjectWrap.cs @@ -0,0 +1,1053 @@ +#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; +using BF; + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class UnityEngineGameObjectWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.GameObject); + Utils.BeginObjectRegister(type, L, translator, 0, 14, 9, 3); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetComponent", _m_GetComponent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetComponentInChildren", _m_GetComponentInChildren); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetComponentInParent", _m_GetComponentInParent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetComponents", _m_GetComponents); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetComponentsInChildren", _m_GetComponentsInChildren); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetComponentsInParent", _m_GetComponentsInParent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryGetComponent", _m_TryGetComponent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SendMessageUpwards", _m_SendMessageUpwards); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SendMessage", _m_SendMessage); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "BroadcastMessage", _m_BroadcastMessage); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddComponent", _m_AddComponent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetActive", _m_SetActive); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CompareTag", _m_CompareTag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "BFGetComponent", _m_BFGetComponent); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "transform", _g_get_transform); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "layer", _g_get_layer); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "activeSelf", _g_get_activeSelf); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "activeInHierarchy", _g_get_activeInHierarchy); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isStatic", _g_get_isStatic); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "tag", _g_get_tag); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "scene", _g_get_scene); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sceneCullingMask", _g_get_sceneCullingMask); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "gameObject", _g_get_gameObject); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "layer", _s_set_layer); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "isStatic", _s_set_isStatic); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "tag", _s_set_tag); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 6, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CreatePrimitive", _m_CreatePrimitive_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FindWithTag", _m_FindWithTag_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FindGameObjectWithTag", _m_FindGameObjectWithTag_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FindGameObjectsWithTag", _m_FindGameObjectsWithTag_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Find", _m_Find_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) == 2 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = new UnityEngine.GameObject(_name); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new UnityEngine.GameObject(); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) >= 2 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING) && (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 3) || translator.Assignable(L, 3))) + { + string _name = LuaAPI.lua_tostring(L, 2); + System.Type[] _components = translator.GetParams(L, 3); + + var gen_ret = new UnityEngine.GameObject(_name, _components); + 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 UnityEngine.GameObject constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CreatePrimitive_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.PrimitiveType _type;translator.Get(L, 1, out _type); + + var gen_ret = UnityEngine.GameObject.CreatePrimitive( _type ); + 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_GetComponent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.GameObject gen_to_be_invoked = (UnityEngine.GameObject)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.Type _type = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + + var gen_ret = gen_to_be_invoked.GetComponent( _type ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _type = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetComponent( _type ); + 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 UnityEngine.GameObject.GetComponent!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetComponentInChildren(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.GameObject gen_to_be_invoked = (UnityEngine.GameObject)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.Type _type = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + + var gen_ret = gen_to_be_invoked.GetComponentInChildren( _type ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + System.Type _type = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + bool _includeInactive = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.GetComponentInChildren( _type, _includeInactive ); + 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 UnityEngine.GameObject.GetComponentInChildren!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetComponentInParent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.GameObject gen_to_be_invoked = (UnityEngine.GameObject)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.Type _type = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + + var gen_ret = gen_to_be_invoked.GetComponentInParent( _type ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + System.Type _type = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + bool _includeInactive = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.GetComponentInParent( _type, _includeInactive ); + 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 UnityEngine.GameObject.GetComponentInParent!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetComponents(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.GameObject gen_to_be_invoked = (UnityEngine.GameObject)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.Type _type = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + + var gen_ret = gen_to_be_invoked.GetComponents( _type ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable>(L, 3)) + { + System.Type _type = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + System.Collections.Generic.List _results = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetComponents( _type, _results ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.GameObject.GetComponents!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetComponentsInChildren(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.GameObject gen_to_be_invoked = (UnityEngine.GameObject)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.Type _type = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + + var gen_ret = gen_to_be_invoked.GetComponentsInChildren( _type ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + System.Type _type = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + bool _includeInactive = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.GetComponentsInChildren( _type, _includeInactive ); + 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 UnityEngine.GameObject.GetComponentsInChildren!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetComponentsInParent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.GameObject gen_to_be_invoked = (UnityEngine.GameObject)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.Type _type = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + + var gen_ret = gen_to_be_invoked.GetComponentsInParent( _type ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + System.Type _type = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + bool _includeInactive = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.GetComponentsInParent( _type, _includeInactive ); + 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 UnityEngine.GameObject.GetComponentsInParent!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TryGetComponent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.GameObject gen_to_be_invoked = (UnityEngine.GameObject)translator.FastGetCSObj(L, 1); + + + + { + System.Type _type = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + UnityEngine.Component _component; + + var gen_ret = gen_to_be_invoked.TryGetComponent( _type, out _component ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _component); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FindWithTag_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _tag = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.GameObject.FindWithTag( _tag ); + 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_SendMessageUpwards(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.GameObject gen_to_be_invoked = (UnityEngine.GameObject)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _methodName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SendMessageUpwards( _methodName ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _methodName = LuaAPI.lua_tostring(L, 2); + UnityEngine.SendMessageOptions _options;translator.Get(L, 3, out _options); + + gen_to_be_invoked.SendMessageUpwards( _methodName, _options ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _methodName = LuaAPI.lua_tostring(L, 2); + object _value = translator.GetObject(L, 3, typeof(object)); + + gen_to_be_invoked.SendMessageUpwards( _methodName, _value ); + + + + return 0; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + string _methodName = LuaAPI.lua_tostring(L, 2); + object _value = translator.GetObject(L, 3, typeof(object)); + UnityEngine.SendMessageOptions _options;translator.Get(L, 4, out _options); + + gen_to_be_invoked.SendMessageUpwards( _methodName, _value, _options ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.GameObject.SendMessageUpwards!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SendMessage(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.GameObject gen_to_be_invoked = (UnityEngine.GameObject)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _methodName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SendMessage( _methodName ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _methodName = LuaAPI.lua_tostring(L, 2); + UnityEngine.SendMessageOptions _options;translator.Get(L, 3, out _options); + + gen_to_be_invoked.SendMessage( _methodName, _options ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _methodName = LuaAPI.lua_tostring(L, 2); + object _value = translator.GetObject(L, 3, typeof(object)); + + gen_to_be_invoked.SendMessage( _methodName, _value ); + + + + return 0; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + string _methodName = LuaAPI.lua_tostring(L, 2); + object _value = translator.GetObject(L, 3, typeof(object)); + UnityEngine.SendMessageOptions _options;translator.Get(L, 4, out _options); + + gen_to_be_invoked.SendMessage( _methodName, _value, _options ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.GameObject.SendMessage!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_BroadcastMessage(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.GameObject gen_to_be_invoked = (UnityEngine.GameObject)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _methodName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.BroadcastMessage( _methodName ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _methodName = LuaAPI.lua_tostring(L, 2); + UnityEngine.SendMessageOptions _options;translator.Get(L, 3, out _options); + + gen_to_be_invoked.BroadcastMessage( _methodName, _options ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _methodName = LuaAPI.lua_tostring(L, 2); + object _parameter = translator.GetObject(L, 3, typeof(object)); + + gen_to_be_invoked.BroadcastMessage( _methodName, _parameter ); + + + + return 0; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + string _methodName = LuaAPI.lua_tostring(L, 2); + object _parameter = translator.GetObject(L, 3, typeof(object)); + UnityEngine.SendMessageOptions _options;translator.Get(L, 4, out _options); + + gen_to_be_invoked.BroadcastMessage( _methodName, _parameter, _options ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.GameObject.BroadcastMessage!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddComponent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.GameObject gen_to_be_invoked = (UnityEngine.GameObject)translator.FastGetCSObj(L, 1); + + + + { + System.Type _componentType = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + + var gen_ret = gen_to_be_invoked.AddComponent( _componentType ); + 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_SetActive(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.GameObject gen_to_be_invoked = (UnityEngine.GameObject)translator.FastGetCSObj(L, 1); + + + + { + bool _value = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.SetActive( _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CompareTag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.GameObject gen_to_be_invoked = (UnityEngine.GameObject)translator.FastGetCSObj(L, 1); + + + + { + string _tag = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.CompareTag( _tag ); + 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_FindGameObjectWithTag_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _tag = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.GameObject.FindGameObjectWithTag( _tag ); + 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_FindGameObjectsWithTag_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _tag = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.GameObject.FindGameObjectsWithTag( _tag ); + 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_Find_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _name = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.GameObject.Find( _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_BFGetComponent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.GameObject gen_to_be_invoked = (UnityEngine.GameObject)translator.FastGetCSObj(L, 1); + + + + { + System.Type _componentType = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + + var gen_ret = gen_to_be_invoked.BFGetComponent( _componentType ); + 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_transform(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.GameObject gen_to_be_invoked = (UnityEngine.GameObject)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.transform); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_layer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.GameObject gen_to_be_invoked = (UnityEngine.GameObject)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.layer); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_activeSelf(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.GameObject gen_to_be_invoked = (UnityEngine.GameObject)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.activeSelf); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_activeInHierarchy(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.GameObject gen_to_be_invoked = (UnityEngine.GameObject)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.activeInHierarchy); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isStatic(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.GameObject gen_to_be_invoked = (UnityEngine.GameObject)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isStatic); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_tag(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.GameObject gen_to_be_invoked = (UnityEngine.GameObject)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.tag); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_scene(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.GameObject gen_to_be_invoked = (UnityEngine.GameObject)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.scene); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sceneCullingMask(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.GameObject gen_to_be_invoked = (UnityEngine.GameObject)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushuint64(L, gen_to_be_invoked.sceneCullingMask); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_gameObject(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.GameObject gen_to_be_invoked = (UnityEngine.GameObject)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.gameObject); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_layer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.GameObject gen_to_be_invoked = (UnityEngine.GameObject)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.layer = 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_isStatic(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.GameObject gen_to_be_invoked = (UnityEngine.GameObject)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.isStatic = 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_tag(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.GameObject gen_to_be_invoked = (UnityEngine.GameObject)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.tag = 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/UnityEngine_GraphicsWrap.cs b/Assets/XLua/Gen/UnityEngine_GraphicsWrap.cs new file mode 100644 index 000000000..196feb6fe --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_GraphicsWrap.cs @@ -0,0 +1,3834 @@ +#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 UnityEngineGraphicsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Graphics); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 31, 6, 1); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetRenderTarget", _m_SetRenderTarget_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetRandomWriteTarget", _m_SetRandomWriteTarget_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CopyTexture", _m_CopyTexture_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ConvertTexture", _m_ConvertTexture_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CreateAsyncGraphicsFence", _m_CreateAsyncGraphicsFence_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CreateGraphicsFence", _m_CreateGraphicsFence_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "WaitOnAsyncGraphicsFence", _m_WaitOnAsyncGraphicsFence_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CopyBuffer", _m_CopyBuffer_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "DrawTexture", _m_DrawTexture_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RenderMesh", _m_RenderMesh_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RenderMeshIndirect", _m_RenderMeshIndirect_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RenderMeshPrimitives", _m_RenderMeshPrimitives_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RenderPrimitives", _m_RenderPrimitives_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RenderPrimitivesIndexed", _m_RenderPrimitivesIndexed_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RenderPrimitivesIndirect", _m_RenderPrimitivesIndirect_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RenderPrimitivesIndexedIndirect", _m_RenderPrimitivesIndexedIndirect_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "DrawMeshNow", _m_DrawMeshNow_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "DrawMesh", _m_DrawMesh_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "DrawMeshInstanced", _m_DrawMeshInstanced_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "DrawMeshInstancedProcedural", _m_DrawMeshInstancedProcedural_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "DrawMeshInstancedIndirect", _m_DrawMeshInstancedIndirect_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "DrawProceduralNow", _m_DrawProceduralNow_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "DrawProceduralIndirectNow", _m_DrawProceduralIndirectNow_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "DrawProcedural", _m_DrawProcedural_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "DrawProceduralIndirect", _m_DrawProceduralIndirect_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Blit", _m_Blit_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "BlitMultiTap", _m_BlitMultiTap_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ClearRandomWriteTargets", _m_ClearRandomWriteTargets_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ExecuteCommandBuffer", _m_ExecuteCommandBuffer_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ExecuteCommandBufferAsync", _m_ExecuteCommandBufferAsync_xlua_st_); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "activeColorBuffer", _g_get_activeColorBuffer); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "activeDepthBuffer", _g_get_activeDepthBuffer); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "activeColorGamut", _g_get_activeColorGamut); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "activeTier", _g_get_activeTier); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "preserveFramebufferAlpha", _g_get_preserveFramebufferAlpha); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "minOpenGLESVersion", _g_get_minOpenGLESVersion); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "activeTier", _s_set_activeTier); + + + 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 UnityEngine.Graphics(); + 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 UnityEngine.Graphics constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRenderTarget_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + UnityEngine.RenderTargetSetup _setup;translator.Get(L, 1, out _setup); + + UnityEngine.Graphics.SetRenderTarget( _setup ); + + + + return 0; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + UnityEngine.RenderTexture _rt = (UnityEngine.RenderTexture)translator.GetObject(L, 1, typeof(UnityEngine.RenderTexture)); + + UnityEngine.Graphics.SetRenderTarget( _rt ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + UnityEngine.RenderTexture _rt = (UnityEngine.RenderTexture)translator.GetObject(L, 1, typeof(UnityEngine.RenderTexture)); + int _mipLevel = LuaAPI.xlua_tointeger(L, 2); + + UnityEngine.Graphics.SetRenderTarget( _rt, _mipLevel ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.RenderBuffer[] _colorBuffers = (UnityEngine.RenderBuffer[])translator.GetObject(L, 1, typeof(UnityEngine.RenderBuffer[])); + UnityEngine.RenderBuffer _depthBuffer;translator.Get(L, 2, out _depthBuffer); + + UnityEngine.Graphics.SetRenderTarget( _colorBuffers, _depthBuffer ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.RenderBuffer _colorBuffer;translator.Get(L, 1, out _colorBuffer); + UnityEngine.RenderBuffer _depthBuffer;translator.Get(L, 2, out _depthBuffer); + + UnityEngine.Graphics.SetRenderTarget( _colorBuffer, _depthBuffer ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.RenderTexture _rt = (UnityEngine.RenderTexture)translator.GetObject(L, 1, typeof(UnityEngine.RenderTexture)); + int _mipLevel = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.CubemapFace _face;translator.Get(L, 3, out _face); + + UnityEngine.Graphics.SetRenderTarget( _rt, _mipLevel, _face ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.RenderBuffer _colorBuffer;translator.Get(L, 1, out _colorBuffer); + UnityEngine.RenderBuffer _depthBuffer;translator.Get(L, 2, out _depthBuffer); + int _mipLevel = LuaAPI.xlua_tointeger(L, 3); + + UnityEngine.Graphics.SetRenderTarget( _colorBuffer, _depthBuffer, _mipLevel ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.RenderTexture _rt = (UnityEngine.RenderTexture)translator.GetObject(L, 1, typeof(UnityEngine.RenderTexture)); + int _mipLevel = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.CubemapFace _face;translator.Get(L, 3, out _face); + int _depthSlice = LuaAPI.xlua_tointeger(L, 4); + + UnityEngine.Graphics.SetRenderTarget( _rt, _mipLevel, _face, _depthSlice ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.RenderBuffer _colorBuffer;translator.Get(L, 1, out _colorBuffer); + UnityEngine.RenderBuffer _depthBuffer;translator.Get(L, 2, out _depthBuffer); + int _mipLevel = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.CubemapFace _face;translator.Get(L, 4, out _face); + + UnityEngine.Graphics.SetRenderTarget( _colorBuffer, _depthBuffer, _mipLevel, _face ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.RenderBuffer _colorBuffer;translator.Get(L, 1, out _colorBuffer); + UnityEngine.RenderBuffer _depthBuffer;translator.Get(L, 2, out _depthBuffer); + int _mipLevel = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.CubemapFace _face;translator.Get(L, 4, out _face); + int _depthSlice = LuaAPI.xlua_tointeger(L, 5); + + UnityEngine.Graphics.SetRenderTarget( _colorBuffer, _depthBuffer, _mipLevel, _face, _depthSlice ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Graphics.SetRenderTarget!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRandomWriteTarget_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + int _index = LuaAPI.xlua_tointeger(L, 1); + UnityEngine.RenderTexture _uav = (UnityEngine.RenderTexture)translator.GetObject(L, 2, typeof(UnityEngine.RenderTexture)); + + UnityEngine.Graphics.SetRandomWriteTarget( _index, _uav ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + int _index = LuaAPI.xlua_tointeger(L, 1); + UnityEngine.ComputeBuffer _uav = (UnityEngine.ComputeBuffer)translator.GetObject(L, 2, typeof(UnityEngine.ComputeBuffer)); + + UnityEngine.Graphics.SetRandomWriteTarget( _index, _uav ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + int _index = LuaAPI.xlua_tointeger(L, 1); + UnityEngine.GraphicsBuffer _uav = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 2, typeof(UnityEngine.GraphicsBuffer)); + + UnityEngine.Graphics.SetRandomWriteTarget( _index, _uav ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + int _index = LuaAPI.xlua_tointeger(L, 1); + UnityEngine.ComputeBuffer _uav = (UnityEngine.ComputeBuffer)translator.GetObject(L, 2, typeof(UnityEngine.ComputeBuffer)); + bool _preserveCounterValue = LuaAPI.lua_toboolean(L, 3); + + UnityEngine.Graphics.SetRandomWriteTarget( _index, _uav, _preserveCounterValue ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + int _index = LuaAPI.xlua_tointeger(L, 1); + UnityEngine.GraphicsBuffer _uav = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 2, typeof(UnityEngine.GraphicsBuffer)); + bool _preserveCounterValue = LuaAPI.lua_toboolean(L, 3); + + UnityEngine.Graphics.SetRandomWriteTarget( _index, _uav, _preserveCounterValue ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Graphics.SetRandomWriteTarget!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CopyTexture_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.Texture _src = (UnityEngine.Texture)translator.GetObject(L, 1, typeof(UnityEngine.Texture)); + UnityEngine.Texture _dst = (UnityEngine.Texture)translator.GetObject(L, 2, typeof(UnityEngine.Texture)); + + UnityEngine.Graphics.CopyTexture( _src, _dst ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Texture _src = (UnityEngine.Texture)translator.GetObject(L, 1, typeof(UnityEngine.Texture)); + int _srcElement = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Texture _dst = (UnityEngine.Texture)translator.GetObject(L, 3, typeof(UnityEngine.Texture)); + int _dstElement = LuaAPI.xlua_tointeger(L, 4); + + UnityEngine.Graphics.CopyTexture( _src, _srcElement, _dst, _dstElement ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Texture _src = (UnityEngine.Texture)translator.GetObject(L, 1, typeof(UnityEngine.Texture)); + int _srcElement = LuaAPI.xlua_tointeger(L, 2); + int _srcMip = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.Texture _dst = (UnityEngine.Texture)translator.GetObject(L, 4, typeof(UnityEngine.Texture)); + int _dstElement = LuaAPI.xlua_tointeger(L, 5); + int _dstMip = LuaAPI.xlua_tointeger(L, 6); + + UnityEngine.Graphics.CopyTexture( _src, _srcElement, _srcMip, _dst, _dstElement, _dstMip ); + + + + return 0; + } + if(gen_param_count == 12&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)&& translator.Assignable(L, 8)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 9)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 10)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 11)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 12)) + { + UnityEngine.Texture _src = (UnityEngine.Texture)translator.GetObject(L, 1, typeof(UnityEngine.Texture)); + int _srcElement = LuaAPI.xlua_tointeger(L, 2); + int _srcMip = LuaAPI.xlua_tointeger(L, 3); + int _srcX = LuaAPI.xlua_tointeger(L, 4); + int _srcY = LuaAPI.xlua_tointeger(L, 5); + int _srcWidth = LuaAPI.xlua_tointeger(L, 6); + int _srcHeight = LuaAPI.xlua_tointeger(L, 7); + UnityEngine.Texture _dst = (UnityEngine.Texture)translator.GetObject(L, 8, typeof(UnityEngine.Texture)); + int _dstElement = LuaAPI.xlua_tointeger(L, 9); + int _dstMip = LuaAPI.xlua_tointeger(L, 10); + int _dstX = LuaAPI.xlua_tointeger(L, 11); + int _dstY = LuaAPI.xlua_tointeger(L, 12); + + UnityEngine.Graphics.CopyTexture( _src, _srcElement, _srcMip, _srcX, _srcY, _srcWidth, _srcHeight, _dst, _dstElement, _dstMip, _dstX, _dstY ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Graphics.CopyTexture!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ConvertTexture_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.Texture _src = (UnityEngine.Texture)translator.GetObject(L, 1, typeof(UnityEngine.Texture)); + UnityEngine.Texture _dst = (UnityEngine.Texture)translator.GetObject(L, 2, typeof(UnityEngine.Texture)); + + var gen_ret = UnityEngine.Graphics.ConvertTexture( _src, _dst ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Texture _src = (UnityEngine.Texture)translator.GetObject(L, 1, typeof(UnityEngine.Texture)); + int _srcElement = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Texture _dst = (UnityEngine.Texture)translator.GetObject(L, 3, typeof(UnityEngine.Texture)); + int _dstElement = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = UnityEngine.Graphics.ConvertTexture( _src, _srcElement, _dst, _dstElement ); + LuaAPI.lua_pushboolean(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 UnityEngine.Graphics.ConvertTexture!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CreateAsyncGraphicsFence_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 0) + { + + var gen_ret = UnityEngine.Graphics.CreateAsyncGraphicsFence( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + UnityEngine.Rendering.SynchronisationStage _stage;translator.Get(L, 1, out _stage); + + var gen_ret = UnityEngine.Graphics.CreateAsyncGraphicsFence( _stage ); + 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 UnityEngine.Graphics.CreateAsyncGraphicsFence!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CreateGraphicsFence_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Rendering.GraphicsFenceType _fenceType;translator.Get(L, 1, out _fenceType); + UnityEngine.Rendering.SynchronisationStageFlags _stage;translator.Get(L, 2, out _stage); + + var gen_ret = UnityEngine.Graphics.CreateGraphicsFence( _fenceType, _stage ); + 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_WaitOnAsyncGraphicsFence_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + UnityEngine.Rendering.GraphicsFence _fence;translator.Get(L, 1, out _fence); + + UnityEngine.Graphics.WaitOnAsyncGraphicsFence( _fence ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.Rendering.GraphicsFence _fence;translator.Get(L, 1, out _fence); + UnityEngine.Rendering.SynchronisationStage _stage;translator.Get(L, 2, out _stage); + + UnityEngine.Graphics.WaitOnAsyncGraphicsFence( _fence, _stage ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Graphics.WaitOnAsyncGraphicsFence!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CopyBuffer_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.GraphicsBuffer _source = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 1, typeof(UnityEngine.GraphicsBuffer)); + UnityEngine.GraphicsBuffer _dest = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 2, typeof(UnityEngine.GraphicsBuffer)); + + UnityEngine.Graphics.CopyBuffer( _source, _dest ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DrawTexture_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.Rect _screenRect;translator.Get(L, 1, out _screenRect); + UnityEngine.Texture _texture = (UnityEngine.Texture)translator.GetObject(L, 2, typeof(UnityEngine.Texture)); + + UnityEngine.Graphics.DrawTexture( _screenRect, _texture ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Rect _screenRect;translator.Get(L, 1, out _screenRect); + UnityEngine.Texture _texture = (UnityEngine.Texture)translator.GetObject(L, 2, typeof(UnityEngine.Texture)); + int _leftBorder = LuaAPI.xlua_tointeger(L, 3); + int _rightBorder = LuaAPI.xlua_tointeger(L, 4); + int _topBorder = LuaAPI.xlua_tointeger(L, 5); + int _bottomBorder = LuaAPI.xlua_tointeger(L, 6); + + UnityEngine.Graphics.DrawTexture( _screenRect, _texture, _leftBorder, _rightBorder, _topBorder, _bottomBorder ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Rect _screenRect;translator.Get(L, 1, out _screenRect); + UnityEngine.Texture _texture = (UnityEngine.Texture)translator.GetObject(L, 2, typeof(UnityEngine.Texture)); + UnityEngine.Material _mat = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + + UnityEngine.Graphics.DrawTexture( _screenRect, _texture, _mat ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Rect _screenRect;translator.Get(L, 1, out _screenRect); + UnityEngine.Texture _texture = (UnityEngine.Texture)translator.GetObject(L, 2, typeof(UnityEngine.Texture)); + UnityEngine.Material _mat = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + int _pass = LuaAPI.xlua_tointeger(L, 4); + + UnityEngine.Graphics.DrawTexture( _screenRect, _texture, _mat, _pass ); + + + + return 0; + } + if(gen_param_count == 7&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)) + { + UnityEngine.Rect _screenRect;translator.Get(L, 1, out _screenRect); + UnityEngine.Texture _texture = (UnityEngine.Texture)translator.GetObject(L, 2, typeof(UnityEngine.Texture)); + UnityEngine.Rect _sourceRect;translator.Get(L, 3, out _sourceRect); + int _leftBorder = LuaAPI.xlua_tointeger(L, 4); + int _rightBorder = LuaAPI.xlua_tointeger(L, 5); + int _topBorder = LuaAPI.xlua_tointeger(L, 6); + int _bottomBorder = LuaAPI.xlua_tointeger(L, 7); + + UnityEngine.Graphics.DrawTexture( _screenRect, _texture, _sourceRect, _leftBorder, _rightBorder, _topBorder, _bottomBorder ); + + + + return 0; + } + if(gen_param_count == 7&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)) + { + UnityEngine.Rect _screenRect;translator.Get(L, 1, out _screenRect); + UnityEngine.Texture _texture = (UnityEngine.Texture)translator.GetObject(L, 2, typeof(UnityEngine.Texture)); + int _leftBorder = LuaAPI.xlua_tointeger(L, 3); + int _rightBorder = LuaAPI.xlua_tointeger(L, 4); + int _topBorder = LuaAPI.xlua_tointeger(L, 5); + int _bottomBorder = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.Material _mat = (UnityEngine.Material)translator.GetObject(L, 7, typeof(UnityEngine.Material)); + + UnityEngine.Graphics.DrawTexture( _screenRect, _texture, _leftBorder, _rightBorder, _topBorder, _bottomBorder, _mat ); + + + + return 0; + } + if(gen_param_count == 8&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 8)) + { + UnityEngine.Rect _screenRect;translator.Get(L, 1, out _screenRect); + UnityEngine.Texture _texture = (UnityEngine.Texture)translator.GetObject(L, 2, typeof(UnityEngine.Texture)); + int _leftBorder = LuaAPI.xlua_tointeger(L, 3); + int _rightBorder = LuaAPI.xlua_tointeger(L, 4); + int _topBorder = LuaAPI.xlua_tointeger(L, 5); + int _bottomBorder = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.Material _mat = (UnityEngine.Material)translator.GetObject(L, 7, typeof(UnityEngine.Material)); + int _pass = LuaAPI.xlua_tointeger(L, 8); + + UnityEngine.Graphics.DrawTexture( _screenRect, _texture, _leftBorder, _rightBorder, _topBorder, _bottomBorder, _mat, _pass ); + + + + return 0; + } + if(gen_param_count == 8&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)&& translator.Assignable(L, 8)) + { + UnityEngine.Rect _screenRect;translator.Get(L, 1, out _screenRect); + UnityEngine.Texture _texture = (UnityEngine.Texture)translator.GetObject(L, 2, typeof(UnityEngine.Texture)); + UnityEngine.Rect _sourceRect;translator.Get(L, 3, out _sourceRect); + int _leftBorder = LuaAPI.xlua_tointeger(L, 4); + int _rightBorder = LuaAPI.xlua_tointeger(L, 5); + int _topBorder = LuaAPI.xlua_tointeger(L, 6); + int _bottomBorder = LuaAPI.xlua_tointeger(L, 7); + UnityEngine.Color _color;translator.Get(L, 8, out _color); + + UnityEngine.Graphics.DrawTexture( _screenRect, _texture, _sourceRect, _leftBorder, _rightBorder, _topBorder, _bottomBorder, _color ); + + + + return 0; + } + if(gen_param_count == 8&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)&& translator.Assignable(L, 8)) + { + UnityEngine.Rect _screenRect;translator.Get(L, 1, out _screenRect); + UnityEngine.Texture _texture = (UnityEngine.Texture)translator.GetObject(L, 2, typeof(UnityEngine.Texture)); + UnityEngine.Rect _sourceRect;translator.Get(L, 3, out _sourceRect); + int _leftBorder = LuaAPI.xlua_tointeger(L, 4); + int _rightBorder = LuaAPI.xlua_tointeger(L, 5); + int _topBorder = LuaAPI.xlua_tointeger(L, 6); + int _bottomBorder = LuaAPI.xlua_tointeger(L, 7); + UnityEngine.Material _mat = (UnityEngine.Material)translator.GetObject(L, 8, typeof(UnityEngine.Material)); + + UnityEngine.Graphics.DrawTexture( _screenRect, _texture, _sourceRect, _leftBorder, _rightBorder, _topBorder, _bottomBorder, _mat ); + + + + return 0; + } + if(gen_param_count == 9&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)&& translator.Assignable(L, 8)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 9)) + { + UnityEngine.Rect _screenRect;translator.Get(L, 1, out _screenRect); + UnityEngine.Texture _texture = (UnityEngine.Texture)translator.GetObject(L, 2, typeof(UnityEngine.Texture)); + UnityEngine.Rect _sourceRect;translator.Get(L, 3, out _sourceRect); + int _leftBorder = LuaAPI.xlua_tointeger(L, 4); + int _rightBorder = LuaAPI.xlua_tointeger(L, 5); + int _topBorder = LuaAPI.xlua_tointeger(L, 6); + int _bottomBorder = LuaAPI.xlua_tointeger(L, 7); + UnityEngine.Material _mat = (UnityEngine.Material)translator.GetObject(L, 8, typeof(UnityEngine.Material)); + int _pass = LuaAPI.xlua_tointeger(L, 9); + + UnityEngine.Graphics.DrawTexture( _screenRect, _texture, _sourceRect, _leftBorder, _rightBorder, _topBorder, _bottomBorder, _mat, _pass ); + + + + return 0; + } + if(gen_param_count == 9&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)&& translator.Assignable(L, 8)&& translator.Assignable(L, 9)) + { + UnityEngine.Rect _screenRect;translator.Get(L, 1, out _screenRect); + UnityEngine.Texture _texture = (UnityEngine.Texture)translator.GetObject(L, 2, typeof(UnityEngine.Texture)); + UnityEngine.Rect _sourceRect;translator.Get(L, 3, out _sourceRect); + int _leftBorder = LuaAPI.xlua_tointeger(L, 4); + int _rightBorder = LuaAPI.xlua_tointeger(L, 5); + int _topBorder = LuaAPI.xlua_tointeger(L, 6); + int _bottomBorder = LuaAPI.xlua_tointeger(L, 7); + UnityEngine.Color _color;translator.Get(L, 8, out _color); + UnityEngine.Material _mat = (UnityEngine.Material)translator.GetObject(L, 9, typeof(UnityEngine.Material)); + + UnityEngine.Graphics.DrawTexture( _screenRect, _texture, _sourceRect, _leftBorder, _rightBorder, _topBorder, _bottomBorder, _color, _mat ); + + + + return 0; + } + if(gen_param_count == 10&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)&& translator.Assignable(L, 8)&& translator.Assignable(L, 9)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 10)) + { + UnityEngine.Rect _screenRect;translator.Get(L, 1, out _screenRect); + UnityEngine.Texture _texture = (UnityEngine.Texture)translator.GetObject(L, 2, typeof(UnityEngine.Texture)); + UnityEngine.Rect _sourceRect;translator.Get(L, 3, out _sourceRect); + int _leftBorder = LuaAPI.xlua_tointeger(L, 4); + int _rightBorder = LuaAPI.xlua_tointeger(L, 5); + int _topBorder = LuaAPI.xlua_tointeger(L, 6); + int _bottomBorder = LuaAPI.xlua_tointeger(L, 7); + UnityEngine.Color _color;translator.Get(L, 8, out _color); + UnityEngine.Material _mat = (UnityEngine.Material)translator.GetObject(L, 9, typeof(UnityEngine.Material)); + int _pass = LuaAPI.xlua_tointeger(L, 10); + + UnityEngine.Graphics.DrawTexture( _screenRect, _texture, _sourceRect, _leftBorder, _rightBorder, _topBorder, _bottomBorder, _color, _mat, _pass ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Graphics.DrawTexture!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RenderMesh_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable>(L, 5)) + { + UnityEngine.RenderParams _rparams;translator.Get(L, 1, out _rparams); + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.Matrix4x4 _objectToWorld;translator.Get(L, 4, out _objectToWorld); + System.Nullable _prevObjectToWorld;translator.Get(L, 5, out _prevObjectToWorld); + + UnityEngine.Graphics.RenderMesh( _rparams, _mesh, _submeshIndex, _objectToWorld, _prevObjectToWorld ); + translator.Push(L, _rparams); + translator.Update(L, 1, _rparams); + + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.RenderParams _rparams;translator.Get(L, 1, out _rparams); + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.Matrix4x4 _objectToWorld;translator.Get(L, 4, out _objectToWorld); + + UnityEngine.Graphics.RenderMesh( _rparams, _mesh, _submeshIndex, _objectToWorld ); + translator.Push(L, _rparams); + translator.Update(L, 1, _rparams); + + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Graphics.RenderMesh!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RenderMeshIndirect_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.RenderParams _rparams;translator.Get(L, 1, out _rparams); + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + UnityEngine.GraphicsBuffer _commandBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 3, typeof(UnityEngine.GraphicsBuffer)); + int _commandCount = LuaAPI.xlua_tointeger(L, 4); + int _startCommand = LuaAPI.xlua_tointeger(L, 5); + + UnityEngine.Graphics.RenderMeshIndirect( _rparams, _mesh, _commandBuffer, _commandCount, _startCommand ); + translator.Push(L, _rparams); + translator.Update(L, 1, _rparams); + + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.RenderParams _rparams;translator.Get(L, 1, out _rparams); + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + UnityEngine.GraphicsBuffer _commandBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 3, typeof(UnityEngine.GraphicsBuffer)); + int _commandCount = LuaAPI.xlua_tointeger(L, 4); + + UnityEngine.Graphics.RenderMeshIndirect( _rparams, _mesh, _commandBuffer, _commandCount ); + translator.Push(L, _rparams); + translator.Update(L, 1, _rparams); + + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.RenderParams _rparams;translator.Get(L, 1, out _rparams); + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + UnityEngine.GraphicsBuffer _commandBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 3, typeof(UnityEngine.GraphicsBuffer)); + + UnityEngine.Graphics.RenderMeshIndirect( _rparams, _mesh, _commandBuffer ); + translator.Push(L, _rparams); + translator.Update(L, 1, _rparams); + + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Graphics.RenderMeshIndirect!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RenderMeshPrimitives_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.RenderParams _rparams;translator.Get(L, 1, out _rparams); + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 3); + int _instanceCount = LuaAPI.xlua_tointeger(L, 4); + + UnityEngine.Graphics.RenderMeshPrimitives( _rparams, _mesh, _submeshIndex, _instanceCount ); + translator.Push(L, _rparams); + translator.Update(L, 1, _rparams); + + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.RenderParams _rparams;translator.Get(L, 1, out _rparams); + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 3); + + UnityEngine.Graphics.RenderMeshPrimitives( _rparams, _mesh, _submeshIndex ); + translator.Push(L, _rparams); + translator.Update(L, 1, _rparams); + + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Graphics.RenderMeshPrimitives!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RenderPrimitives_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.RenderParams _rparams;translator.Get(L, 1, out _rparams); + UnityEngine.MeshTopology _topology;translator.Get(L, 2, out _topology); + int _vertexCount = LuaAPI.xlua_tointeger(L, 3); + int _instanceCount = LuaAPI.xlua_tointeger(L, 4); + + UnityEngine.Graphics.RenderPrimitives( _rparams, _topology, _vertexCount, _instanceCount ); + translator.Push(L, _rparams); + translator.Update(L, 1, _rparams); + + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.RenderParams _rparams;translator.Get(L, 1, out _rparams); + UnityEngine.MeshTopology _topology;translator.Get(L, 2, out _topology); + int _vertexCount = LuaAPI.xlua_tointeger(L, 3); + + UnityEngine.Graphics.RenderPrimitives( _rparams, _topology, _vertexCount ); + translator.Push(L, _rparams); + translator.Update(L, 1, _rparams); + + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Graphics.RenderPrimitives!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RenderPrimitivesIndexed_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 6&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + UnityEngine.RenderParams _rparams;translator.Get(L, 1, out _rparams); + UnityEngine.MeshTopology _topology;translator.Get(L, 2, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 3, typeof(UnityEngine.GraphicsBuffer)); + int _indexCount = LuaAPI.xlua_tointeger(L, 4); + int _startIndex = LuaAPI.xlua_tointeger(L, 5); + int _instanceCount = LuaAPI.xlua_tointeger(L, 6); + + UnityEngine.Graphics.RenderPrimitivesIndexed( _rparams, _topology, _indexBuffer, _indexCount, _startIndex, _instanceCount ); + translator.Push(L, _rparams); + translator.Update(L, 1, _rparams); + + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.RenderParams _rparams;translator.Get(L, 1, out _rparams); + UnityEngine.MeshTopology _topology;translator.Get(L, 2, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 3, typeof(UnityEngine.GraphicsBuffer)); + int _indexCount = LuaAPI.xlua_tointeger(L, 4); + int _startIndex = LuaAPI.xlua_tointeger(L, 5); + + UnityEngine.Graphics.RenderPrimitivesIndexed( _rparams, _topology, _indexBuffer, _indexCount, _startIndex ); + translator.Push(L, _rparams); + translator.Update(L, 1, _rparams); + + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.RenderParams _rparams;translator.Get(L, 1, out _rparams); + UnityEngine.MeshTopology _topology;translator.Get(L, 2, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 3, typeof(UnityEngine.GraphicsBuffer)); + int _indexCount = LuaAPI.xlua_tointeger(L, 4); + + UnityEngine.Graphics.RenderPrimitivesIndexed( _rparams, _topology, _indexBuffer, _indexCount ); + translator.Push(L, _rparams); + translator.Update(L, 1, _rparams); + + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Graphics.RenderPrimitivesIndexed!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RenderPrimitivesIndirect_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.RenderParams _rparams;translator.Get(L, 1, out _rparams); + UnityEngine.MeshTopology _topology;translator.Get(L, 2, out _topology); + UnityEngine.GraphicsBuffer _commandBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 3, typeof(UnityEngine.GraphicsBuffer)); + int _commandCount = LuaAPI.xlua_tointeger(L, 4); + int _startCommand = LuaAPI.xlua_tointeger(L, 5); + + UnityEngine.Graphics.RenderPrimitivesIndirect( _rparams, _topology, _commandBuffer, _commandCount, _startCommand ); + translator.Push(L, _rparams); + translator.Update(L, 1, _rparams); + + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.RenderParams _rparams;translator.Get(L, 1, out _rparams); + UnityEngine.MeshTopology _topology;translator.Get(L, 2, out _topology); + UnityEngine.GraphicsBuffer _commandBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 3, typeof(UnityEngine.GraphicsBuffer)); + int _commandCount = LuaAPI.xlua_tointeger(L, 4); + + UnityEngine.Graphics.RenderPrimitivesIndirect( _rparams, _topology, _commandBuffer, _commandCount ); + translator.Push(L, _rparams); + translator.Update(L, 1, _rparams); + + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.RenderParams _rparams;translator.Get(L, 1, out _rparams); + UnityEngine.MeshTopology _topology;translator.Get(L, 2, out _topology); + UnityEngine.GraphicsBuffer _commandBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 3, typeof(UnityEngine.GraphicsBuffer)); + + UnityEngine.Graphics.RenderPrimitivesIndirect( _rparams, _topology, _commandBuffer ); + translator.Push(L, _rparams); + translator.Update(L, 1, _rparams); + + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Graphics.RenderPrimitivesIndirect!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RenderPrimitivesIndexedIndirect_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 6&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + UnityEngine.RenderParams _rparams;translator.Get(L, 1, out _rparams); + UnityEngine.MeshTopology _topology;translator.Get(L, 2, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 3, typeof(UnityEngine.GraphicsBuffer)); + UnityEngine.GraphicsBuffer _commandBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + int _commandCount = LuaAPI.xlua_tointeger(L, 5); + int _startCommand = LuaAPI.xlua_tointeger(L, 6); + + UnityEngine.Graphics.RenderPrimitivesIndexedIndirect( _rparams, _topology, _indexBuffer, _commandBuffer, _commandCount, _startCommand ); + translator.Push(L, _rparams); + translator.Update(L, 1, _rparams); + + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.RenderParams _rparams;translator.Get(L, 1, out _rparams); + UnityEngine.MeshTopology _topology;translator.Get(L, 2, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 3, typeof(UnityEngine.GraphicsBuffer)); + UnityEngine.GraphicsBuffer _commandBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + int _commandCount = LuaAPI.xlua_tointeger(L, 5); + + UnityEngine.Graphics.RenderPrimitivesIndexedIndirect( _rparams, _topology, _indexBuffer, _commandBuffer, _commandCount ); + translator.Push(L, _rparams); + translator.Update(L, 1, _rparams); + + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.RenderParams _rparams;translator.Get(L, 1, out _rparams); + UnityEngine.MeshTopology _topology;translator.Get(L, 2, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 3, typeof(UnityEngine.GraphicsBuffer)); + UnityEngine.GraphicsBuffer _commandBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + + UnityEngine.Graphics.RenderPrimitivesIndexedIndirect( _rparams, _topology, _indexBuffer, _commandBuffer ); + translator.Push(L, _rparams); + translator.Update(L, 1, _rparams); + + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Graphics.RenderPrimitivesIndexedIndirect!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DrawMeshNow_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + UnityEngine.Matrix4x4 _matrix;translator.Get(L, 2, out _matrix); + + UnityEngine.Graphics.DrawMeshNow( _mesh, _matrix ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + UnityEngine.Matrix4x4 _matrix;translator.Get(L, 2, out _matrix); + int _materialIndex = LuaAPI.xlua_tointeger(L, 3); + + UnityEngine.Graphics.DrawMeshNow( _mesh, _matrix, _materialIndex ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + UnityEngine.Quaternion _rotation;translator.Get(L, 3, out _rotation); + + UnityEngine.Graphics.DrawMeshNow( _mesh, _position, _rotation ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + UnityEngine.Quaternion _rotation;translator.Get(L, 3, out _rotation); + int _materialIndex = LuaAPI.xlua_tointeger(L, 4); + + UnityEngine.Graphics.DrawMeshNow( _mesh, _position, _rotation, _materialIndex ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Graphics.DrawMeshNow!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DrawMesh_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + UnityEngine.Matrix4x4 _matrix;translator.Get(L, 2, out _matrix); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + int _layer = LuaAPI.xlua_tointeger(L, 4); + + UnityEngine.Graphics.DrawMesh( _mesh, _matrix, _material, _layer ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + UnityEngine.Quaternion _rotation;translator.Get(L, 3, out _rotation); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 4, typeof(UnityEngine.Material)); + int _layer = LuaAPI.xlua_tointeger(L, 5); + + UnityEngine.Graphics.DrawMesh( _mesh, _position, _rotation, _material, _layer ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + UnityEngine.Matrix4x4 _matrix;translator.Get(L, 2, out _matrix); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + int _layer = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 5, typeof(UnityEngine.Camera)); + + UnityEngine.Graphics.DrawMesh( _mesh, _matrix, _material, _layer, _camera ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + UnityEngine.Matrix4x4 _matrix;translator.Get(L, 2, out _matrix); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + int _layer = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 5, typeof(UnityEngine.Camera)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 6); + + UnityEngine.Graphics.DrawMesh( _mesh, _matrix, _material, _layer, _camera, _submeshIndex ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + UnityEngine.Quaternion _rotation;translator.Get(L, 3, out _rotation); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 4, typeof(UnityEngine.Material)); + int _layer = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 6, typeof(UnityEngine.Camera)); + + UnityEngine.Graphics.DrawMesh( _mesh, _position, _rotation, _material, _layer, _camera ); + + + + return 0; + } + if(gen_param_count == 7&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + UnityEngine.Quaternion _rotation;translator.Get(L, 3, out _rotation); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 4, typeof(UnityEngine.Material)); + int _layer = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 6, typeof(UnityEngine.Camera)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 7); + + UnityEngine.Graphics.DrawMesh( _mesh, _position, _rotation, _material, _layer, _camera, _submeshIndex ); + + + + return 0; + } + if(gen_param_count == 7&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + UnityEngine.Matrix4x4 _matrix;translator.Get(L, 2, out _matrix); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + int _layer = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 5, typeof(UnityEngine.Camera)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + + UnityEngine.Graphics.DrawMesh( _mesh, _matrix, _material, _layer, _camera, _submeshIndex, _properties ); + + + + return 0; + } + if(gen_param_count == 8&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 8)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + UnityEngine.Matrix4x4 _matrix;translator.Get(L, 2, out _matrix); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + int _layer = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 5, typeof(UnityEngine.Camera)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + bool _castShadows = LuaAPI.lua_toboolean(L, 8); + + UnityEngine.Graphics.DrawMesh( _mesh, _matrix, _material, _layer, _camera, _submeshIndex, _properties, _castShadows ); + + + + return 0; + } + if(gen_param_count == 9&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 8)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 9)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + UnityEngine.Matrix4x4 _matrix;translator.Get(L, 2, out _matrix); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + int _layer = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 5, typeof(UnityEngine.Camera)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + bool _castShadows = LuaAPI.lua_toboolean(L, 8); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 9); + + UnityEngine.Graphics.DrawMesh( _mesh, _matrix, _material, _layer, _camera, _submeshIndex, _properties, _castShadows, _receiveShadows ); + + + + return 0; + } + if(gen_param_count == 10&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 8)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 9)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 10)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + UnityEngine.Matrix4x4 _matrix;translator.Get(L, 2, out _matrix); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + int _layer = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 5, typeof(UnityEngine.Camera)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + bool _castShadows = LuaAPI.lua_toboolean(L, 8); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 9); + bool _useLightProbes = LuaAPI.lua_toboolean(L, 10); + + UnityEngine.Graphics.DrawMesh( _mesh, _matrix, _material, _layer, _camera, _submeshIndex, _properties, _castShadows, _receiveShadows, _useLightProbes ); + + + + return 0; + } + if(gen_param_count == 8&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)&& translator.Assignable(L, 8)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + UnityEngine.Quaternion _rotation;translator.Get(L, 3, out _rotation); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 4, typeof(UnityEngine.Material)); + int _layer = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 6, typeof(UnityEngine.Camera)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 7); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 8, typeof(UnityEngine.MaterialPropertyBlock)); + + UnityEngine.Graphics.DrawMesh( _mesh, _position, _rotation, _material, _layer, _camera, _submeshIndex, _properties ); + + + + return 0; + } + if(gen_param_count == 8&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + UnityEngine.Matrix4x4 _matrix;translator.Get(L, 2, out _matrix); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + int _layer = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 5, typeof(UnityEngine.Camera)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 8, out _castShadows); + + UnityEngine.Graphics.DrawMesh( _mesh, _matrix, _material, _layer, _camera, _submeshIndex, _properties, _castShadows ); + + + + return 0; + } + if(gen_param_count == 9&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)&& translator.Assignable(L, 8)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 9)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + UnityEngine.Quaternion _rotation;translator.Get(L, 3, out _rotation); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 4, typeof(UnityEngine.Material)); + int _layer = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 6, typeof(UnityEngine.Camera)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 7); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 8, typeof(UnityEngine.MaterialPropertyBlock)); + bool _castShadows = LuaAPI.lua_toboolean(L, 9); + + UnityEngine.Graphics.DrawMesh( _mesh, _position, _rotation, _material, _layer, _camera, _submeshIndex, _properties, _castShadows ); + + + + return 0; + } + if(gen_param_count == 9&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 9)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + UnityEngine.Matrix4x4 _matrix;translator.Get(L, 2, out _matrix); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + int _layer = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 5, typeof(UnityEngine.Camera)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 8, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 9); + + UnityEngine.Graphics.DrawMesh( _mesh, _matrix, _material, _layer, _camera, _submeshIndex, _properties, _castShadows, _receiveShadows ); + + + + return 0; + } + if(gen_param_count == 10&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)&& translator.Assignable(L, 8)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 9)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 10)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + UnityEngine.Quaternion _rotation;translator.Get(L, 3, out _rotation); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 4, typeof(UnityEngine.Material)); + int _layer = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 6, typeof(UnityEngine.Camera)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 7); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 8, typeof(UnityEngine.MaterialPropertyBlock)); + bool _castShadows = LuaAPI.lua_toboolean(L, 9); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 10); + + UnityEngine.Graphics.DrawMesh( _mesh, _position, _rotation, _material, _layer, _camera, _submeshIndex, _properties, _castShadows, _receiveShadows ); + + + + return 0; + } + if(gen_param_count == 11&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)&& translator.Assignable(L, 8)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 9)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 10)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 11)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + UnityEngine.Quaternion _rotation;translator.Get(L, 3, out _rotation); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 4, typeof(UnityEngine.Material)); + int _layer = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 6, typeof(UnityEngine.Camera)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 7); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 8, typeof(UnityEngine.MaterialPropertyBlock)); + bool _castShadows = LuaAPI.lua_toboolean(L, 9); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 10); + bool _useLightProbes = LuaAPI.lua_toboolean(L, 11); + + UnityEngine.Graphics.DrawMesh( _mesh, _position, _rotation, _material, _layer, _camera, _submeshIndex, _properties, _castShadows, _receiveShadows, _useLightProbes ); + + + + return 0; + } + if(gen_param_count == 9&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)&& translator.Assignable(L, 8)&& translator.Assignable(L, 9)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + UnityEngine.Quaternion _rotation;translator.Get(L, 3, out _rotation); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 4, typeof(UnityEngine.Material)); + int _layer = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 6, typeof(UnityEngine.Camera)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 7); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 8, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 9, out _castShadows); + + UnityEngine.Graphics.DrawMesh( _mesh, _position, _rotation, _material, _layer, _camera, _submeshIndex, _properties, _castShadows ); + + + + return 0; + } + if(gen_param_count == 10&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)&& translator.Assignable(L, 8)&& translator.Assignable(L, 9)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 10)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + UnityEngine.Quaternion _rotation;translator.Get(L, 3, out _rotation); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 4, typeof(UnityEngine.Material)); + int _layer = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 6, typeof(UnityEngine.Camera)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 7); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 8, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 9, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 10); + + UnityEngine.Graphics.DrawMesh( _mesh, _position, _rotation, _material, _layer, _camera, _submeshIndex, _properties, _castShadows, _receiveShadows ); + + + + return 0; + } + if(gen_param_count == 10&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 9)&& translator.Assignable(L, 10)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + UnityEngine.Matrix4x4 _matrix;translator.Get(L, 2, out _matrix); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + int _layer = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 5, typeof(UnityEngine.Camera)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 8, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 9); + UnityEngine.Transform _probeAnchor = (UnityEngine.Transform)translator.GetObject(L, 10, typeof(UnityEngine.Transform)); + + UnityEngine.Graphics.DrawMesh( _mesh, _matrix, _material, _layer, _camera, _submeshIndex, _properties, _castShadows, _receiveShadows, _probeAnchor ); + + + + return 0; + } + if(gen_param_count == 11&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 9)&& translator.Assignable(L, 10)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 11)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + UnityEngine.Matrix4x4 _matrix;translator.Get(L, 2, out _matrix); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + int _layer = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 5, typeof(UnityEngine.Camera)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 8, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 9); + UnityEngine.Transform _probeAnchor = (UnityEngine.Transform)translator.GetObject(L, 10, typeof(UnityEngine.Transform)); + bool _useLightProbes = LuaAPI.lua_toboolean(L, 11); + + UnityEngine.Graphics.DrawMesh( _mesh, _matrix, _material, _layer, _camera, _submeshIndex, _properties, _castShadows, _receiveShadows, _probeAnchor, _useLightProbes ); + + + + return 0; + } + if(gen_param_count == 11&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)&& translator.Assignable(L, 8)&& translator.Assignable(L, 9)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 10)&& translator.Assignable(L, 11)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + UnityEngine.Quaternion _rotation;translator.Get(L, 3, out _rotation); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 4, typeof(UnityEngine.Material)); + int _layer = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 6, typeof(UnityEngine.Camera)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 7); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 8, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 9, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 10); + UnityEngine.Transform _probeAnchor = (UnityEngine.Transform)translator.GetObject(L, 11, typeof(UnityEngine.Transform)); + + UnityEngine.Graphics.DrawMesh( _mesh, _position, _rotation, _material, _layer, _camera, _submeshIndex, _properties, _castShadows, _receiveShadows, _probeAnchor ); + + + + return 0; + } + if(gen_param_count == 11&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 9)&& translator.Assignable(L, 10)&& translator.Assignable(L, 11)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + UnityEngine.Matrix4x4 _matrix;translator.Get(L, 2, out _matrix); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + int _layer = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 5, typeof(UnityEngine.Camera)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 8, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 9); + UnityEngine.Transform _probeAnchor = (UnityEngine.Transform)translator.GetObject(L, 10, typeof(UnityEngine.Transform)); + UnityEngine.Rendering.LightProbeUsage _lightProbeUsage;translator.Get(L, 11, out _lightProbeUsage); + + UnityEngine.Graphics.DrawMesh( _mesh, _matrix, _material, _layer, _camera, _submeshIndex, _properties, _castShadows, _receiveShadows, _probeAnchor, _lightProbeUsage ); + + + + return 0; + } + if(gen_param_count == 12&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)&& translator.Assignable(L, 8)&& translator.Assignable(L, 9)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 10)&& translator.Assignable(L, 11)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 12)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + UnityEngine.Quaternion _rotation;translator.Get(L, 3, out _rotation); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 4, typeof(UnityEngine.Material)); + int _layer = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 6, typeof(UnityEngine.Camera)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 7); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 8, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 9, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 10); + UnityEngine.Transform _probeAnchor = (UnityEngine.Transform)translator.GetObject(L, 11, typeof(UnityEngine.Transform)); + bool _useLightProbes = LuaAPI.lua_toboolean(L, 12); + + UnityEngine.Graphics.DrawMesh( _mesh, _position, _rotation, _material, _layer, _camera, _submeshIndex, _properties, _castShadows, _receiveShadows, _probeAnchor, _useLightProbes ); + + + + return 0; + } + if(gen_param_count == 12&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 9)&& translator.Assignable(L, 10)&& translator.Assignable(L, 11)&& translator.Assignable(L, 12)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + UnityEngine.Matrix4x4 _matrix;translator.Get(L, 2, out _matrix); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + int _layer = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 5, typeof(UnityEngine.Camera)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 8, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 9); + UnityEngine.Transform _probeAnchor = (UnityEngine.Transform)translator.GetObject(L, 10, typeof(UnityEngine.Transform)); + UnityEngine.Rendering.LightProbeUsage _lightProbeUsage;translator.Get(L, 11, out _lightProbeUsage); + UnityEngine.LightProbeProxyVolume _lightProbeProxyVolume = (UnityEngine.LightProbeProxyVolume)translator.GetObject(L, 12, typeof(UnityEngine.LightProbeProxyVolume)); + + UnityEngine.Graphics.DrawMesh( _mesh, _matrix, _material, _layer, _camera, _submeshIndex, _properties, _castShadows, _receiveShadows, _probeAnchor, _lightProbeUsage, _lightProbeProxyVolume ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Graphics.DrawMesh!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DrawMeshInstanced_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Matrix4x4[] _matrices = (UnityEngine.Matrix4x4[])translator.GetObject(L, 4, typeof(UnityEngine.Matrix4x4[])); + + UnityEngine.Graphics.DrawMeshInstanced( _mesh, _submeshIndex, _material, _matrices ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable>(L, 4)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + System.Collections.Generic.List _matrices = (System.Collections.Generic.List)translator.GetObject(L, 4, typeof(System.Collections.Generic.List)); + + UnityEngine.Graphics.DrawMeshInstanced( _mesh, _submeshIndex, _material, _matrices ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Matrix4x4[] _matrices = (UnityEngine.Matrix4x4[])translator.GetObject(L, 4, typeof(UnityEngine.Matrix4x4[])); + int _count = LuaAPI.xlua_tointeger(L, 5); + + UnityEngine.Graphics.DrawMeshInstanced( _mesh, _submeshIndex, _material, _matrices, _count ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable>(L, 4)&& translator.Assignable(L, 5)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + System.Collections.Generic.List _matrices = (System.Collections.Generic.List)translator.GetObject(L, 4, typeof(System.Collections.Generic.List)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 5, typeof(UnityEngine.MaterialPropertyBlock)); + + UnityEngine.Graphics.DrawMeshInstanced( _mesh, _submeshIndex, _material, _matrices, _properties ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Matrix4x4[] _matrices = (UnityEngine.Matrix4x4[])translator.GetObject(L, 4, typeof(UnityEngine.Matrix4x4[])); + int _count = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 6, typeof(UnityEngine.MaterialPropertyBlock)); + + UnityEngine.Graphics.DrawMeshInstanced( _mesh, _submeshIndex, _material, _matrices, _count, _properties ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable>(L, 4)&& translator.Assignable(L, 5)&& translator.Assignable(L, 6)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + System.Collections.Generic.List _matrices = (System.Collections.Generic.List)translator.GetObject(L, 4, typeof(System.Collections.Generic.List)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 5, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 6, out _castShadows); + + UnityEngine.Graphics.DrawMeshInstanced( _mesh, _submeshIndex, _material, _matrices, _properties, _castShadows ); + + + + return 0; + } + if(gen_param_count == 7&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& translator.Assignable(L, 7)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Matrix4x4[] _matrices = (UnityEngine.Matrix4x4[])translator.GetObject(L, 4, typeof(UnityEngine.Matrix4x4[])); + int _count = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 6, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 7, out _castShadows); + + UnityEngine.Graphics.DrawMeshInstanced( _mesh, _submeshIndex, _material, _matrices, _count, _properties, _castShadows ); + + + + return 0; + } + if(gen_param_count == 7&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable>(L, 4)&& translator.Assignable(L, 5)&& translator.Assignable(L, 6)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 7)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + System.Collections.Generic.List _matrices = (System.Collections.Generic.List)translator.GetObject(L, 4, typeof(System.Collections.Generic.List)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 5, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 6, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 7); + + UnityEngine.Graphics.DrawMeshInstanced( _mesh, _submeshIndex, _material, _matrices, _properties, _castShadows, _receiveShadows ); + + + + return 0; + } + if(gen_param_count == 8&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& translator.Assignable(L, 7)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 8)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Matrix4x4[] _matrices = (UnityEngine.Matrix4x4[])translator.GetObject(L, 4, typeof(UnityEngine.Matrix4x4[])); + int _count = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 6, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 7, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 8); + + UnityEngine.Graphics.DrawMeshInstanced( _mesh, _submeshIndex, _material, _matrices, _count, _properties, _castShadows, _receiveShadows ); + + + + return 0; + } + if(gen_param_count == 8&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable>(L, 4)&& translator.Assignable(L, 5)&& translator.Assignable(L, 6)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 7)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 8)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + System.Collections.Generic.List _matrices = (System.Collections.Generic.List)translator.GetObject(L, 4, typeof(System.Collections.Generic.List)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 5, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 6, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 7); + int _layer = LuaAPI.xlua_tointeger(L, 8); + + UnityEngine.Graphics.DrawMeshInstanced( _mesh, _submeshIndex, _material, _matrices, _properties, _castShadows, _receiveShadows, _layer ); + + + + return 0; + } + if(gen_param_count == 9&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& translator.Assignable(L, 7)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 8)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 9)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Matrix4x4[] _matrices = (UnityEngine.Matrix4x4[])translator.GetObject(L, 4, typeof(UnityEngine.Matrix4x4[])); + int _count = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 6, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 7, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 8); + int _layer = LuaAPI.xlua_tointeger(L, 9); + + UnityEngine.Graphics.DrawMeshInstanced( _mesh, _submeshIndex, _material, _matrices, _count, _properties, _castShadows, _receiveShadows, _layer ); + + + + return 0; + } + if(gen_param_count == 9&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable>(L, 4)&& translator.Assignable(L, 5)&& translator.Assignable(L, 6)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 7)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 8)&& translator.Assignable(L, 9)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + System.Collections.Generic.List _matrices = (System.Collections.Generic.List)translator.GetObject(L, 4, typeof(System.Collections.Generic.List)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 5, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 6, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 7); + int _layer = LuaAPI.xlua_tointeger(L, 8); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 9, typeof(UnityEngine.Camera)); + + UnityEngine.Graphics.DrawMeshInstanced( _mesh, _submeshIndex, _material, _matrices, _properties, _castShadows, _receiveShadows, _layer, _camera ); + + + + return 0; + } + if(gen_param_count == 10&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& translator.Assignable(L, 7)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 8)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 9)&& translator.Assignable(L, 10)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Matrix4x4[] _matrices = (UnityEngine.Matrix4x4[])translator.GetObject(L, 4, typeof(UnityEngine.Matrix4x4[])); + int _count = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 6, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 7, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 8); + int _layer = LuaAPI.xlua_tointeger(L, 9); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 10, typeof(UnityEngine.Camera)); + + UnityEngine.Graphics.DrawMeshInstanced( _mesh, _submeshIndex, _material, _matrices, _count, _properties, _castShadows, _receiveShadows, _layer, _camera ); + + + + return 0; + } + if(gen_param_count == 10&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable>(L, 4)&& translator.Assignable(L, 5)&& translator.Assignable(L, 6)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 7)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 8)&& translator.Assignable(L, 9)&& translator.Assignable(L, 10)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + System.Collections.Generic.List _matrices = (System.Collections.Generic.List)translator.GetObject(L, 4, typeof(System.Collections.Generic.List)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 5, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 6, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 7); + int _layer = LuaAPI.xlua_tointeger(L, 8); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 9, typeof(UnityEngine.Camera)); + UnityEngine.Rendering.LightProbeUsage _lightProbeUsage;translator.Get(L, 10, out _lightProbeUsage); + + UnityEngine.Graphics.DrawMeshInstanced( _mesh, _submeshIndex, _material, _matrices, _properties, _castShadows, _receiveShadows, _layer, _camera, _lightProbeUsage ); + + + + return 0; + } + if(gen_param_count == 11&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& translator.Assignable(L, 7)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 8)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 9)&& translator.Assignable(L, 10)&& translator.Assignable(L, 11)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Matrix4x4[] _matrices = (UnityEngine.Matrix4x4[])translator.GetObject(L, 4, typeof(UnityEngine.Matrix4x4[])); + int _count = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 6, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 7, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 8); + int _layer = LuaAPI.xlua_tointeger(L, 9); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 10, typeof(UnityEngine.Camera)); + UnityEngine.Rendering.LightProbeUsage _lightProbeUsage;translator.Get(L, 11, out _lightProbeUsage); + + UnityEngine.Graphics.DrawMeshInstanced( _mesh, _submeshIndex, _material, _matrices, _count, _properties, _castShadows, _receiveShadows, _layer, _camera, _lightProbeUsage ); + + + + return 0; + } + if(gen_param_count == 11&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable>(L, 4)&& translator.Assignable(L, 5)&& translator.Assignable(L, 6)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 7)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 8)&& translator.Assignable(L, 9)&& translator.Assignable(L, 10)&& translator.Assignable(L, 11)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + System.Collections.Generic.List _matrices = (System.Collections.Generic.List)translator.GetObject(L, 4, typeof(System.Collections.Generic.List)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 5, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 6, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 7); + int _layer = LuaAPI.xlua_tointeger(L, 8); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 9, typeof(UnityEngine.Camera)); + UnityEngine.Rendering.LightProbeUsage _lightProbeUsage;translator.Get(L, 10, out _lightProbeUsage); + UnityEngine.LightProbeProxyVolume _lightProbeProxyVolume = (UnityEngine.LightProbeProxyVolume)translator.GetObject(L, 11, typeof(UnityEngine.LightProbeProxyVolume)); + + UnityEngine.Graphics.DrawMeshInstanced( _mesh, _submeshIndex, _material, _matrices, _properties, _castShadows, _receiveShadows, _layer, _camera, _lightProbeUsage, _lightProbeProxyVolume ); + + + + return 0; + } + if(gen_param_count == 12&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& translator.Assignable(L, 7)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 8)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 9)&& translator.Assignable(L, 10)&& translator.Assignable(L, 11)&& translator.Assignable(L, 12)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Matrix4x4[] _matrices = (UnityEngine.Matrix4x4[])translator.GetObject(L, 4, typeof(UnityEngine.Matrix4x4[])); + int _count = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 6, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 7, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 8); + int _layer = LuaAPI.xlua_tointeger(L, 9); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 10, typeof(UnityEngine.Camera)); + UnityEngine.Rendering.LightProbeUsage _lightProbeUsage;translator.Get(L, 11, out _lightProbeUsage); + UnityEngine.LightProbeProxyVolume _lightProbeProxyVolume = (UnityEngine.LightProbeProxyVolume)translator.GetObject(L, 12, typeof(UnityEngine.LightProbeProxyVolume)); + + UnityEngine.Graphics.DrawMeshInstanced( _mesh, _submeshIndex, _material, _matrices, _count, _properties, _castShadows, _receiveShadows, _layer, _camera, _lightProbeUsage, _lightProbeProxyVolume ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Graphics.DrawMeshInstanced!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DrawMeshInstancedProcedural_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 12&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& translator.Assignable(L, 7)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 8)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 9)&& translator.Assignable(L, 10)&& translator.Assignable(L, 11)&& translator.Assignable(L, 12)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 4, out _bounds); + int _count = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 6, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 7, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 8); + int _layer = LuaAPI.xlua_tointeger(L, 9); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 10, typeof(UnityEngine.Camera)); + UnityEngine.Rendering.LightProbeUsage _lightProbeUsage;translator.Get(L, 11, out _lightProbeUsage); + UnityEngine.LightProbeProxyVolume _lightProbeProxyVolume = (UnityEngine.LightProbeProxyVolume)translator.GetObject(L, 12, typeof(UnityEngine.LightProbeProxyVolume)); + + UnityEngine.Graphics.DrawMeshInstancedProcedural( _mesh, _submeshIndex, _material, _bounds, _count, _properties, _castShadows, _receiveShadows, _layer, _camera, _lightProbeUsage, _lightProbeProxyVolume ); + + + + return 0; + } + if(gen_param_count == 11&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& translator.Assignable(L, 7)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 8)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 9)&& translator.Assignable(L, 10)&& translator.Assignable(L, 11)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 4, out _bounds); + int _count = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 6, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 7, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 8); + int _layer = LuaAPI.xlua_tointeger(L, 9); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 10, typeof(UnityEngine.Camera)); + UnityEngine.Rendering.LightProbeUsage _lightProbeUsage;translator.Get(L, 11, out _lightProbeUsage); + + UnityEngine.Graphics.DrawMeshInstancedProcedural( _mesh, _submeshIndex, _material, _bounds, _count, _properties, _castShadows, _receiveShadows, _layer, _camera, _lightProbeUsage ); + + + + return 0; + } + if(gen_param_count == 10&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& translator.Assignable(L, 7)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 8)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 9)&& translator.Assignable(L, 10)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 4, out _bounds); + int _count = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 6, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 7, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 8); + int _layer = LuaAPI.xlua_tointeger(L, 9); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 10, typeof(UnityEngine.Camera)); + + UnityEngine.Graphics.DrawMeshInstancedProcedural( _mesh, _submeshIndex, _material, _bounds, _count, _properties, _castShadows, _receiveShadows, _layer, _camera ); + + + + return 0; + } + if(gen_param_count == 9&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& translator.Assignable(L, 7)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 8)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 9)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 4, out _bounds); + int _count = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 6, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 7, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 8); + int _layer = LuaAPI.xlua_tointeger(L, 9); + + UnityEngine.Graphics.DrawMeshInstancedProcedural( _mesh, _submeshIndex, _material, _bounds, _count, _properties, _castShadows, _receiveShadows, _layer ); + + + + return 0; + } + if(gen_param_count == 8&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& translator.Assignable(L, 7)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 8)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 4, out _bounds); + int _count = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 6, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 7, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 8); + + UnityEngine.Graphics.DrawMeshInstancedProcedural( _mesh, _submeshIndex, _material, _bounds, _count, _properties, _castShadows, _receiveShadows ); + + + + return 0; + } + if(gen_param_count == 7&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& translator.Assignable(L, 7)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 4, out _bounds); + int _count = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 6, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 7, out _castShadows); + + UnityEngine.Graphics.DrawMeshInstancedProcedural( _mesh, _submeshIndex, _material, _bounds, _count, _properties, _castShadows ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 4, out _bounds); + int _count = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 6, typeof(UnityEngine.MaterialPropertyBlock)); + + UnityEngine.Graphics.DrawMeshInstancedProcedural( _mesh, _submeshIndex, _material, _bounds, _count, _properties ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 4, out _bounds); + int _count = LuaAPI.xlua_tointeger(L, 5); + + UnityEngine.Graphics.DrawMeshInstancedProcedural( _mesh, _submeshIndex, _material, _bounds, _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Graphics.DrawMeshInstancedProcedural!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DrawMeshInstancedIndirect_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 12&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 9)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 10)&& translator.Assignable(L, 11)&& translator.Assignable(L, 12)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 4, out _bounds); + UnityEngine.ComputeBuffer _bufferWithArgs = (UnityEngine.ComputeBuffer)translator.GetObject(L, 5, typeof(UnityEngine.ComputeBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 8, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 9); + int _layer = LuaAPI.xlua_tointeger(L, 10); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 11, typeof(UnityEngine.Camera)); + UnityEngine.Rendering.LightProbeUsage _lightProbeUsage;translator.Get(L, 12, out _lightProbeUsage); + + UnityEngine.Graphics.DrawMeshInstancedIndirect( _mesh, _submeshIndex, _material, _bounds, _bufferWithArgs, _argsOffset, _properties, _castShadows, _receiveShadows, _layer, _camera, _lightProbeUsage ); + + + + return 0; + } + if(gen_param_count == 11&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 9)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 10)&& translator.Assignable(L, 11)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 4, out _bounds); + UnityEngine.ComputeBuffer _bufferWithArgs = (UnityEngine.ComputeBuffer)translator.GetObject(L, 5, typeof(UnityEngine.ComputeBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 8, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 9); + int _layer = LuaAPI.xlua_tointeger(L, 10); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 11, typeof(UnityEngine.Camera)); + + UnityEngine.Graphics.DrawMeshInstancedIndirect( _mesh, _submeshIndex, _material, _bounds, _bufferWithArgs, _argsOffset, _properties, _castShadows, _receiveShadows, _layer, _camera ); + + + + return 0; + } + if(gen_param_count == 10&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 9)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 10)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 4, out _bounds); + UnityEngine.ComputeBuffer _bufferWithArgs = (UnityEngine.ComputeBuffer)translator.GetObject(L, 5, typeof(UnityEngine.ComputeBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 8, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 9); + int _layer = LuaAPI.xlua_tointeger(L, 10); + + UnityEngine.Graphics.DrawMeshInstancedIndirect( _mesh, _submeshIndex, _material, _bounds, _bufferWithArgs, _argsOffset, _properties, _castShadows, _receiveShadows, _layer ); + + + + return 0; + } + if(gen_param_count == 9&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 9)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 4, out _bounds); + UnityEngine.ComputeBuffer _bufferWithArgs = (UnityEngine.ComputeBuffer)translator.GetObject(L, 5, typeof(UnityEngine.ComputeBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 8, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 9); + + UnityEngine.Graphics.DrawMeshInstancedIndirect( _mesh, _submeshIndex, _material, _bounds, _bufferWithArgs, _argsOffset, _properties, _castShadows, _receiveShadows ); + + + + return 0; + } + if(gen_param_count == 8&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 4, out _bounds); + UnityEngine.ComputeBuffer _bufferWithArgs = (UnityEngine.ComputeBuffer)translator.GetObject(L, 5, typeof(UnityEngine.ComputeBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 8, out _castShadows); + + UnityEngine.Graphics.DrawMeshInstancedIndirect( _mesh, _submeshIndex, _material, _bounds, _bufferWithArgs, _argsOffset, _properties, _castShadows ); + + + + return 0; + } + if(gen_param_count == 7&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 4, out _bounds); + UnityEngine.ComputeBuffer _bufferWithArgs = (UnityEngine.ComputeBuffer)translator.GetObject(L, 5, typeof(UnityEngine.ComputeBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + + UnityEngine.Graphics.DrawMeshInstancedIndirect( _mesh, _submeshIndex, _material, _bounds, _bufferWithArgs, _argsOffset, _properties ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 4, out _bounds); + UnityEngine.ComputeBuffer _bufferWithArgs = (UnityEngine.ComputeBuffer)translator.GetObject(L, 5, typeof(UnityEngine.ComputeBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 6); + + UnityEngine.Graphics.DrawMeshInstancedIndirect( _mesh, _submeshIndex, _material, _bounds, _bufferWithArgs, _argsOffset ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 4, out _bounds); + UnityEngine.ComputeBuffer _bufferWithArgs = (UnityEngine.ComputeBuffer)translator.GetObject(L, 5, typeof(UnityEngine.ComputeBuffer)); + + UnityEngine.Graphics.DrawMeshInstancedIndirect( _mesh, _submeshIndex, _material, _bounds, _bufferWithArgs ); + + + + return 0; + } + if(gen_param_count == 12&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 9)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 10)&& translator.Assignable(L, 11)&& translator.Assignable(L, 12)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 4, out _bounds); + UnityEngine.GraphicsBuffer _bufferWithArgs = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 5, typeof(UnityEngine.GraphicsBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 8, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 9); + int _layer = LuaAPI.xlua_tointeger(L, 10); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 11, typeof(UnityEngine.Camera)); + UnityEngine.Rendering.LightProbeUsage _lightProbeUsage;translator.Get(L, 12, out _lightProbeUsage); + + UnityEngine.Graphics.DrawMeshInstancedIndirect( _mesh, _submeshIndex, _material, _bounds, _bufferWithArgs, _argsOffset, _properties, _castShadows, _receiveShadows, _layer, _camera, _lightProbeUsage ); + + + + return 0; + } + if(gen_param_count == 11&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 9)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 10)&& translator.Assignable(L, 11)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 4, out _bounds); + UnityEngine.GraphicsBuffer _bufferWithArgs = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 5, typeof(UnityEngine.GraphicsBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 8, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 9); + int _layer = LuaAPI.xlua_tointeger(L, 10); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 11, typeof(UnityEngine.Camera)); + + UnityEngine.Graphics.DrawMeshInstancedIndirect( _mesh, _submeshIndex, _material, _bounds, _bufferWithArgs, _argsOffset, _properties, _castShadows, _receiveShadows, _layer, _camera ); + + + + return 0; + } + if(gen_param_count == 10&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 9)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 10)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 4, out _bounds); + UnityEngine.GraphicsBuffer _bufferWithArgs = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 5, typeof(UnityEngine.GraphicsBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 8, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 9); + int _layer = LuaAPI.xlua_tointeger(L, 10); + + UnityEngine.Graphics.DrawMeshInstancedIndirect( _mesh, _submeshIndex, _material, _bounds, _bufferWithArgs, _argsOffset, _properties, _castShadows, _receiveShadows, _layer ); + + + + return 0; + } + if(gen_param_count == 9&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 9)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 4, out _bounds); + UnityEngine.GraphicsBuffer _bufferWithArgs = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 5, typeof(UnityEngine.GraphicsBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 8, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 9); + + UnityEngine.Graphics.DrawMeshInstancedIndirect( _mesh, _submeshIndex, _material, _bounds, _bufferWithArgs, _argsOffset, _properties, _castShadows, _receiveShadows ); + + + + return 0; + } + if(gen_param_count == 8&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 4, out _bounds); + UnityEngine.GraphicsBuffer _bufferWithArgs = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 5, typeof(UnityEngine.GraphicsBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 8, out _castShadows); + + UnityEngine.Graphics.DrawMeshInstancedIndirect( _mesh, _submeshIndex, _material, _bounds, _bufferWithArgs, _argsOffset, _properties, _castShadows ); + + + + return 0; + } + if(gen_param_count == 7&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 4, out _bounds); + UnityEngine.GraphicsBuffer _bufferWithArgs = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 5, typeof(UnityEngine.GraphicsBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + + UnityEngine.Graphics.DrawMeshInstancedIndirect( _mesh, _submeshIndex, _material, _bounds, _bufferWithArgs, _argsOffset, _properties ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 4, out _bounds); + UnityEngine.GraphicsBuffer _bufferWithArgs = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 5, typeof(UnityEngine.GraphicsBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 6); + + UnityEngine.Graphics.DrawMeshInstancedIndirect( _mesh, _submeshIndex, _material, _bounds, _bufferWithArgs, _argsOffset ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 4, out _bounds); + UnityEngine.GraphicsBuffer _bufferWithArgs = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 5, typeof(UnityEngine.GraphicsBuffer)); + + UnityEngine.Graphics.DrawMeshInstancedIndirect( _mesh, _submeshIndex, _material, _bounds, _bufferWithArgs ); + + + + return 0; + } + if(gen_param_count == 13&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 9)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 10)&& translator.Assignable(L, 11)&& translator.Assignable(L, 12)&& translator.Assignable(L, 13)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 4, out _bounds); + UnityEngine.ComputeBuffer _bufferWithArgs = (UnityEngine.ComputeBuffer)translator.GetObject(L, 5, typeof(UnityEngine.ComputeBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 8, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 9); + int _layer = LuaAPI.xlua_tointeger(L, 10); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 11, typeof(UnityEngine.Camera)); + UnityEngine.Rendering.LightProbeUsage _lightProbeUsage;translator.Get(L, 12, out _lightProbeUsage); + UnityEngine.LightProbeProxyVolume _lightProbeProxyVolume = (UnityEngine.LightProbeProxyVolume)translator.GetObject(L, 13, typeof(UnityEngine.LightProbeProxyVolume)); + + UnityEngine.Graphics.DrawMeshInstancedIndirect( _mesh, _submeshIndex, _material, _bounds, _bufferWithArgs, _argsOffset, _properties, _castShadows, _receiveShadows, _layer, _camera, _lightProbeUsage, _lightProbeProxyVolume ); + + + + return 0; + } + if(gen_param_count == 13&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 9)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 10)&& translator.Assignable(L, 11)&& translator.Assignable(L, 12)&& translator.Assignable(L, 13)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + int _submeshIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 4, out _bounds); + UnityEngine.GraphicsBuffer _bufferWithArgs = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 5, typeof(UnityEngine.GraphicsBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 8, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 9); + int _layer = LuaAPI.xlua_tointeger(L, 10); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 11, typeof(UnityEngine.Camera)); + UnityEngine.Rendering.LightProbeUsage _lightProbeUsage;translator.Get(L, 12, out _lightProbeUsage); + UnityEngine.LightProbeProxyVolume _lightProbeProxyVolume = (UnityEngine.LightProbeProxyVolume)translator.GetObject(L, 13, typeof(UnityEngine.LightProbeProxyVolume)); + + UnityEngine.Graphics.DrawMeshInstancedIndirect( _mesh, _submeshIndex, _material, _bounds, _bufferWithArgs, _argsOffset, _properties, _castShadows, _receiveShadows, _layer, _camera, _lightProbeUsage, _lightProbeProxyVolume ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Graphics.DrawMeshInstancedIndirect!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DrawProceduralNow_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.MeshTopology _topology;translator.Get(L, 1, out _topology); + int _vertexCount = LuaAPI.xlua_tointeger(L, 2); + int _instanceCount = LuaAPI.xlua_tointeger(L, 3); + + UnityEngine.Graphics.DrawProceduralNow( _topology, _vertexCount, _instanceCount ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + UnityEngine.MeshTopology _topology;translator.Get(L, 1, out _topology); + int _vertexCount = LuaAPI.xlua_tointeger(L, 2); + + UnityEngine.Graphics.DrawProceduralNow( _topology, _vertexCount ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.MeshTopology _topology;translator.Get(L, 1, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 2, typeof(UnityEngine.GraphicsBuffer)); + int _indexCount = LuaAPI.xlua_tointeger(L, 3); + int _instanceCount = LuaAPI.xlua_tointeger(L, 4); + + UnityEngine.Graphics.DrawProceduralNow( _topology, _indexBuffer, _indexCount, _instanceCount ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.MeshTopology _topology;translator.Get(L, 1, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 2, typeof(UnityEngine.GraphicsBuffer)); + int _indexCount = LuaAPI.xlua_tointeger(L, 3); + + UnityEngine.Graphics.DrawProceduralNow( _topology, _indexBuffer, _indexCount ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Graphics.DrawProceduralNow!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DrawProceduralIndirectNow_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.MeshTopology _topology;translator.Get(L, 1, out _topology); + UnityEngine.ComputeBuffer _bufferWithArgs = (UnityEngine.ComputeBuffer)translator.GetObject(L, 2, typeof(UnityEngine.ComputeBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 3); + + UnityEngine.Graphics.DrawProceduralIndirectNow( _topology, _bufferWithArgs, _argsOffset ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.MeshTopology _topology;translator.Get(L, 1, out _topology); + UnityEngine.ComputeBuffer _bufferWithArgs = (UnityEngine.ComputeBuffer)translator.GetObject(L, 2, typeof(UnityEngine.ComputeBuffer)); + + UnityEngine.Graphics.DrawProceduralIndirectNow( _topology, _bufferWithArgs ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.MeshTopology _topology;translator.Get(L, 1, out _topology); + UnityEngine.GraphicsBuffer _bufferWithArgs = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 2, typeof(UnityEngine.GraphicsBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 3); + + UnityEngine.Graphics.DrawProceduralIndirectNow( _topology, _bufferWithArgs, _argsOffset ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.MeshTopology _topology;translator.Get(L, 1, out _topology); + UnityEngine.GraphicsBuffer _bufferWithArgs = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 2, typeof(UnityEngine.GraphicsBuffer)); + + UnityEngine.Graphics.DrawProceduralIndirectNow( _topology, _bufferWithArgs ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.MeshTopology _topology;translator.Get(L, 1, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 2, typeof(UnityEngine.GraphicsBuffer)); + UnityEngine.ComputeBuffer _bufferWithArgs = (UnityEngine.ComputeBuffer)translator.GetObject(L, 3, typeof(UnityEngine.ComputeBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 4); + + UnityEngine.Graphics.DrawProceduralIndirectNow( _topology, _indexBuffer, _bufferWithArgs, _argsOffset ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.MeshTopology _topology;translator.Get(L, 1, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 2, typeof(UnityEngine.GraphicsBuffer)); + UnityEngine.ComputeBuffer _bufferWithArgs = (UnityEngine.ComputeBuffer)translator.GetObject(L, 3, typeof(UnityEngine.ComputeBuffer)); + + UnityEngine.Graphics.DrawProceduralIndirectNow( _topology, _indexBuffer, _bufferWithArgs ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.MeshTopology _topology;translator.Get(L, 1, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 2, typeof(UnityEngine.GraphicsBuffer)); + UnityEngine.GraphicsBuffer _bufferWithArgs = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 3, typeof(UnityEngine.GraphicsBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 4); + + UnityEngine.Graphics.DrawProceduralIndirectNow( _topology, _indexBuffer, _bufferWithArgs, _argsOffset ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.MeshTopology _topology;translator.Get(L, 1, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 2, typeof(UnityEngine.GraphicsBuffer)); + UnityEngine.GraphicsBuffer _bufferWithArgs = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 3, typeof(UnityEngine.GraphicsBuffer)); + + UnityEngine.Graphics.DrawProceduralIndirectNow( _topology, _indexBuffer, _bufferWithArgs ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Graphics.DrawProceduralIndirectNow!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DrawProcedural_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 10&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 9)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 10)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + int _vertexCount = LuaAPI.xlua_tointeger(L, 4); + int _instanceCount = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 6, typeof(UnityEngine.Camera)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 8, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 9); + int _layer = LuaAPI.xlua_tointeger(L, 10); + + UnityEngine.Graphics.DrawProcedural( _material, _bounds, _topology, _vertexCount, _instanceCount, _camera, _properties, _castShadows, _receiveShadows, _layer ); + + + + return 0; + } + if(gen_param_count == 9&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 9)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + int _vertexCount = LuaAPI.xlua_tointeger(L, 4); + int _instanceCount = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 6, typeof(UnityEngine.Camera)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 8, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 9); + + UnityEngine.Graphics.DrawProcedural( _material, _bounds, _topology, _vertexCount, _instanceCount, _camera, _properties, _castShadows, _receiveShadows ); + + + + return 0; + } + if(gen_param_count == 8&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + int _vertexCount = LuaAPI.xlua_tointeger(L, 4); + int _instanceCount = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 6, typeof(UnityEngine.Camera)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 8, out _castShadows); + + UnityEngine.Graphics.DrawProcedural( _material, _bounds, _topology, _vertexCount, _instanceCount, _camera, _properties, _castShadows ); + + + + return 0; + } + if(gen_param_count == 7&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& translator.Assignable(L, 7)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + int _vertexCount = LuaAPI.xlua_tointeger(L, 4); + int _instanceCount = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 6, typeof(UnityEngine.Camera)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + + UnityEngine.Graphics.DrawProcedural( _material, _bounds, _topology, _vertexCount, _instanceCount, _camera, _properties ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + int _vertexCount = LuaAPI.xlua_tointeger(L, 4); + int _instanceCount = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 6, typeof(UnityEngine.Camera)); + + UnityEngine.Graphics.DrawProcedural( _material, _bounds, _topology, _vertexCount, _instanceCount, _camera ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + int _vertexCount = LuaAPI.xlua_tointeger(L, 4); + int _instanceCount = LuaAPI.xlua_tointeger(L, 5); + + UnityEngine.Graphics.DrawProcedural( _material, _bounds, _topology, _vertexCount, _instanceCount ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + int _vertexCount = LuaAPI.xlua_tointeger(L, 4); + + UnityEngine.Graphics.DrawProcedural( _material, _bounds, _topology, _vertexCount ); + + + + return 0; + } + if(gen_param_count == 11&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& translator.Assignable(L, 9)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 10)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 11)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + int _indexCount = LuaAPI.xlua_tointeger(L, 5); + int _instanceCount = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 7, typeof(UnityEngine.Camera)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 8, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 9, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 10); + int _layer = LuaAPI.xlua_tointeger(L, 11); + + UnityEngine.Graphics.DrawProcedural( _material, _bounds, _topology, _indexBuffer, _indexCount, _instanceCount, _camera, _properties, _castShadows, _receiveShadows, _layer ); + + + + return 0; + } + if(gen_param_count == 10&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& translator.Assignable(L, 9)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 10)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + int _indexCount = LuaAPI.xlua_tointeger(L, 5); + int _instanceCount = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 7, typeof(UnityEngine.Camera)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 8, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 9, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 10); + + UnityEngine.Graphics.DrawProcedural( _material, _bounds, _topology, _indexBuffer, _indexCount, _instanceCount, _camera, _properties, _castShadows, _receiveShadows ); + + + + return 0; + } + if(gen_param_count == 9&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& translator.Assignable(L, 9)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + int _indexCount = LuaAPI.xlua_tointeger(L, 5); + int _instanceCount = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 7, typeof(UnityEngine.Camera)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 8, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 9, out _castShadows); + + UnityEngine.Graphics.DrawProcedural( _material, _bounds, _topology, _indexBuffer, _indexCount, _instanceCount, _camera, _properties, _castShadows ); + + + + return 0; + } + if(gen_param_count == 8&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + int _indexCount = LuaAPI.xlua_tointeger(L, 5); + int _instanceCount = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 7, typeof(UnityEngine.Camera)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 8, typeof(UnityEngine.MaterialPropertyBlock)); + + UnityEngine.Graphics.DrawProcedural( _material, _bounds, _topology, _indexBuffer, _indexCount, _instanceCount, _camera, _properties ); + + + + return 0; + } + if(gen_param_count == 7&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + int _indexCount = LuaAPI.xlua_tointeger(L, 5); + int _instanceCount = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 7, typeof(UnityEngine.Camera)); + + UnityEngine.Graphics.DrawProcedural( _material, _bounds, _topology, _indexBuffer, _indexCount, _instanceCount, _camera ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + int _indexCount = LuaAPI.xlua_tointeger(L, 5); + int _instanceCount = LuaAPI.xlua_tointeger(L, 6); + + UnityEngine.Graphics.DrawProcedural( _material, _bounds, _topology, _indexBuffer, _indexCount, _instanceCount ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + int _indexCount = LuaAPI.xlua_tointeger(L, 5); + + UnityEngine.Graphics.DrawProcedural( _material, _bounds, _topology, _indexBuffer, _indexCount ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Graphics.DrawProcedural!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DrawProceduralIndirect_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 10&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 9)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 10)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.ComputeBuffer _bufferWithArgs = (UnityEngine.ComputeBuffer)translator.GetObject(L, 4, typeof(UnityEngine.ComputeBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 6, typeof(UnityEngine.Camera)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 8, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 9); + int _layer = LuaAPI.xlua_tointeger(L, 10); + + UnityEngine.Graphics.DrawProceduralIndirect( _material, _bounds, _topology, _bufferWithArgs, _argsOffset, _camera, _properties, _castShadows, _receiveShadows, _layer ); + + + + return 0; + } + if(gen_param_count == 9&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 9)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.ComputeBuffer _bufferWithArgs = (UnityEngine.ComputeBuffer)translator.GetObject(L, 4, typeof(UnityEngine.ComputeBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 6, typeof(UnityEngine.Camera)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 8, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 9); + + UnityEngine.Graphics.DrawProceduralIndirect( _material, _bounds, _topology, _bufferWithArgs, _argsOffset, _camera, _properties, _castShadows, _receiveShadows ); + + + + return 0; + } + if(gen_param_count == 8&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.ComputeBuffer _bufferWithArgs = (UnityEngine.ComputeBuffer)translator.GetObject(L, 4, typeof(UnityEngine.ComputeBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 6, typeof(UnityEngine.Camera)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 8, out _castShadows); + + UnityEngine.Graphics.DrawProceduralIndirect( _material, _bounds, _topology, _bufferWithArgs, _argsOffset, _camera, _properties, _castShadows ); + + + + return 0; + } + if(gen_param_count == 7&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& translator.Assignable(L, 7)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.ComputeBuffer _bufferWithArgs = (UnityEngine.ComputeBuffer)translator.GetObject(L, 4, typeof(UnityEngine.ComputeBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 6, typeof(UnityEngine.Camera)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + + UnityEngine.Graphics.DrawProceduralIndirect( _material, _bounds, _topology, _bufferWithArgs, _argsOffset, _camera, _properties ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.ComputeBuffer _bufferWithArgs = (UnityEngine.ComputeBuffer)translator.GetObject(L, 4, typeof(UnityEngine.ComputeBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 6, typeof(UnityEngine.Camera)); + + UnityEngine.Graphics.DrawProceduralIndirect( _material, _bounds, _topology, _bufferWithArgs, _argsOffset, _camera ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.ComputeBuffer _bufferWithArgs = (UnityEngine.ComputeBuffer)translator.GetObject(L, 4, typeof(UnityEngine.ComputeBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 5); + + UnityEngine.Graphics.DrawProceduralIndirect( _material, _bounds, _topology, _bufferWithArgs, _argsOffset ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.ComputeBuffer _bufferWithArgs = (UnityEngine.ComputeBuffer)translator.GetObject(L, 4, typeof(UnityEngine.ComputeBuffer)); + + UnityEngine.Graphics.DrawProceduralIndirect( _material, _bounds, _topology, _bufferWithArgs ); + + + + return 0; + } + if(gen_param_count == 10&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 9)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 10)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.GraphicsBuffer _bufferWithArgs = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 6, typeof(UnityEngine.Camera)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 8, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 9); + int _layer = LuaAPI.xlua_tointeger(L, 10); + + UnityEngine.Graphics.DrawProceduralIndirect( _material, _bounds, _topology, _bufferWithArgs, _argsOffset, _camera, _properties, _castShadows, _receiveShadows, _layer ); + + + + return 0; + } + if(gen_param_count == 9&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 9)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.GraphicsBuffer _bufferWithArgs = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 6, typeof(UnityEngine.Camera)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 8, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 9); + + UnityEngine.Graphics.DrawProceduralIndirect( _material, _bounds, _topology, _bufferWithArgs, _argsOffset, _camera, _properties, _castShadows, _receiveShadows ); + + + + return 0; + } + if(gen_param_count == 8&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.GraphicsBuffer _bufferWithArgs = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 6, typeof(UnityEngine.Camera)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 8, out _castShadows); + + UnityEngine.Graphics.DrawProceduralIndirect( _material, _bounds, _topology, _bufferWithArgs, _argsOffset, _camera, _properties, _castShadows ); + + + + return 0; + } + if(gen_param_count == 7&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& translator.Assignable(L, 7)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.GraphicsBuffer _bufferWithArgs = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 6, typeof(UnityEngine.Camera)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 7, typeof(UnityEngine.MaterialPropertyBlock)); + + UnityEngine.Graphics.DrawProceduralIndirect( _material, _bounds, _topology, _bufferWithArgs, _argsOffset, _camera, _properties ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.GraphicsBuffer _bufferWithArgs = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 6, typeof(UnityEngine.Camera)); + + UnityEngine.Graphics.DrawProceduralIndirect( _material, _bounds, _topology, _bufferWithArgs, _argsOffset, _camera ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.GraphicsBuffer _bufferWithArgs = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 5); + + UnityEngine.Graphics.DrawProceduralIndirect( _material, _bounds, _topology, _bufferWithArgs, _argsOffset ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.GraphicsBuffer _bufferWithArgs = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + + UnityEngine.Graphics.DrawProceduralIndirect( _material, _bounds, _topology, _bufferWithArgs ); + + + + return 0; + } + if(gen_param_count == 11&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& translator.Assignable(L, 9)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 10)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 11)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + UnityEngine.ComputeBuffer _bufferWithArgs = (UnityEngine.ComputeBuffer)translator.GetObject(L, 5, typeof(UnityEngine.ComputeBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 7, typeof(UnityEngine.Camera)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 8, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 9, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 10); + int _layer = LuaAPI.xlua_tointeger(L, 11); + + UnityEngine.Graphics.DrawProceduralIndirect( _material, _bounds, _topology, _indexBuffer, _bufferWithArgs, _argsOffset, _camera, _properties, _castShadows, _receiveShadows, _layer ); + + + + return 0; + } + if(gen_param_count == 10&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& translator.Assignable(L, 9)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 10)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + UnityEngine.ComputeBuffer _bufferWithArgs = (UnityEngine.ComputeBuffer)translator.GetObject(L, 5, typeof(UnityEngine.ComputeBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 7, typeof(UnityEngine.Camera)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 8, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 9, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 10); + + UnityEngine.Graphics.DrawProceduralIndirect( _material, _bounds, _topology, _indexBuffer, _bufferWithArgs, _argsOffset, _camera, _properties, _castShadows, _receiveShadows ); + + + + return 0; + } + if(gen_param_count == 9&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& translator.Assignable(L, 9)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + UnityEngine.ComputeBuffer _bufferWithArgs = (UnityEngine.ComputeBuffer)translator.GetObject(L, 5, typeof(UnityEngine.ComputeBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 7, typeof(UnityEngine.Camera)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 8, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 9, out _castShadows); + + UnityEngine.Graphics.DrawProceduralIndirect( _material, _bounds, _topology, _indexBuffer, _bufferWithArgs, _argsOffset, _camera, _properties, _castShadows ); + + + + return 0; + } + if(gen_param_count == 8&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + UnityEngine.ComputeBuffer _bufferWithArgs = (UnityEngine.ComputeBuffer)translator.GetObject(L, 5, typeof(UnityEngine.ComputeBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 7, typeof(UnityEngine.Camera)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 8, typeof(UnityEngine.MaterialPropertyBlock)); + + UnityEngine.Graphics.DrawProceduralIndirect( _material, _bounds, _topology, _indexBuffer, _bufferWithArgs, _argsOffset, _camera, _properties ); + + + + return 0; + } + if(gen_param_count == 7&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + UnityEngine.ComputeBuffer _bufferWithArgs = (UnityEngine.ComputeBuffer)translator.GetObject(L, 5, typeof(UnityEngine.ComputeBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 7, typeof(UnityEngine.Camera)); + + UnityEngine.Graphics.DrawProceduralIndirect( _material, _bounds, _topology, _indexBuffer, _bufferWithArgs, _argsOffset, _camera ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + UnityEngine.ComputeBuffer _bufferWithArgs = (UnityEngine.ComputeBuffer)translator.GetObject(L, 5, typeof(UnityEngine.ComputeBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 6); + + UnityEngine.Graphics.DrawProceduralIndirect( _material, _bounds, _topology, _indexBuffer, _bufferWithArgs, _argsOffset ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + UnityEngine.ComputeBuffer _bufferWithArgs = (UnityEngine.ComputeBuffer)translator.GetObject(L, 5, typeof(UnityEngine.ComputeBuffer)); + + UnityEngine.Graphics.DrawProceduralIndirect( _material, _bounds, _topology, _indexBuffer, _bufferWithArgs ); + + + + return 0; + } + if(gen_param_count == 11&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& translator.Assignable(L, 9)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 10)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 11)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + UnityEngine.GraphicsBuffer _bufferWithArgs = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 5, typeof(UnityEngine.GraphicsBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 7, typeof(UnityEngine.Camera)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 8, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 9, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 10); + int _layer = LuaAPI.xlua_tointeger(L, 11); + + UnityEngine.Graphics.DrawProceduralIndirect( _material, _bounds, _topology, _indexBuffer, _bufferWithArgs, _argsOffset, _camera, _properties, _castShadows, _receiveShadows, _layer ); + + + + return 0; + } + if(gen_param_count == 10&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& translator.Assignable(L, 9)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 10)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + UnityEngine.GraphicsBuffer _bufferWithArgs = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 5, typeof(UnityEngine.GraphicsBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 7, typeof(UnityEngine.Camera)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 8, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 9, out _castShadows); + bool _receiveShadows = LuaAPI.lua_toboolean(L, 10); + + UnityEngine.Graphics.DrawProceduralIndirect( _material, _bounds, _topology, _indexBuffer, _bufferWithArgs, _argsOffset, _camera, _properties, _castShadows, _receiveShadows ); + + + + return 0; + } + if(gen_param_count == 9&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& translator.Assignable(L, 9)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + UnityEngine.GraphicsBuffer _bufferWithArgs = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 5, typeof(UnityEngine.GraphicsBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 7, typeof(UnityEngine.Camera)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 8, typeof(UnityEngine.MaterialPropertyBlock)); + UnityEngine.Rendering.ShadowCastingMode _castShadows;translator.Get(L, 9, out _castShadows); + + UnityEngine.Graphics.DrawProceduralIndirect( _material, _bounds, _topology, _indexBuffer, _bufferWithArgs, _argsOffset, _camera, _properties, _castShadows ); + + + + return 0; + } + if(gen_param_count == 8&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + UnityEngine.GraphicsBuffer _bufferWithArgs = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 5, typeof(UnityEngine.GraphicsBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 7, typeof(UnityEngine.Camera)); + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 8, typeof(UnityEngine.MaterialPropertyBlock)); + + UnityEngine.Graphics.DrawProceduralIndirect( _material, _bounds, _topology, _indexBuffer, _bufferWithArgs, _argsOffset, _camera, _properties ); + + + + return 0; + } + if(gen_param_count == 7&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + UnityEngine.GraphicsBuffer _bufferWithArgs = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 5, typeof(UnityEngine.GraphicsBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 7, typeof(UnityEngine.Camera)); + + UnityEngine.Graphics.DrawProceduralIndirect( _material, _bounds, _topology, _indexBuffer, _bufferWithArgs, _argsOffset, _camera ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + UnityEngine.GraphicsBuffer _bufferWithArgs = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 5, typeof(UnityEngine.GraphicsBuffer)); + int _argsOffset = LuaAPI.xlua_tointeger(L, 6); + + UnityEngine.Graphics.DrawProceduralIndirect( _material, _bounds, _topology, _indexBuffer, _bufferWithArgs, _argsOffset ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)) + { + UnityEngine.Material _material = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + UnityEngine.Bounds _bounds;translator.Get(L, 2, out _bounds); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + UnityEngine.GraphicsBuffer _indexBuffer = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 4, typeof(UnityEngine.GraphicsBuffer)); + UnityEngine.GraphicsBuffer _bufferWithArgs = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 5, typeof(UnityEngine.GraphicsBuffer)); + + UnityEngine.Graphics.DrawProceduralIndirect( _material, _bounds, _topology, _indexBuffer, _bufferWithArgs ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Graphics.DrawProceduralIndirect!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Blit_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.Texture _source = (UnityEngine.Texture)translator.GetObject(L, 1, typeof(UnityEngine.Texture)); + UnityEngine.RenderTexture _dest = (UnityEngine.RenderTexture)translator.GetObject(L, 2, typeof(UnityEngine.RenderTexture)); + + UnityEngine.Graphics.Blit( _source, _dest ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.Texture _source = (UnityEngine.Texture)translator.GetObject(L, 1, typeof(UnityEngine.Texture)); + UnityEngine.Material _mat = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + UnityEngine.Graphics.Blit( _source, _mat ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Texture _source = (UnityEngine.Texture)translator.GetObject(L, 1, typeof(UnityEngine.Texture)); + UnityEngine.Material _mat = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + int _pass = LuaAPI.xlua_tointeger(L, 3); + + UnityEngine.Graphics.Blit( _source, _mat, _pass ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Texture _source = (UnityEngine.Texture)translator.GetObject(L, 1, typeof(UnityEngine.Texture)); + UnityEngine.RenderTexture _dest = (UnityEngine.RenderTexture)translator.GetObject(L, 2, typeof(UnityEngine.RenderTexture)); + int _sourceDepthSlice = LuaAPI.xlua_tointeger(L, 3); + int _destDepthSlice = LuaAPI.xlua_tointeger(L, 4); + + UnityEngine.Graphics.Blit( _source, _dest, _sourceDepthSlice, _destDepthSlice ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Texture _source = (UnityEngine.Texture)translator.GetObject(L, 1, typeof(UnityEngine.Texture)); + UnityEngine.Material _mat = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + int _pass = LuaAPI.xlua_tointeger(L, 3); + int _destDepthSlice = LuaAPI.xlua_tointeger(L, 4); + + UnityEngine.Graphics.Blit( _source, _mat, _pass, _destDepthSlice ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Texture _source = (UnityEngine.Texture)translator.GetObject(L, 1, typeof(UnityEngine.Texture)); + UnityEngine.RenderTexture _dest = (UnityEngine.RenderTexture)translator.GetObject(L, 2, typeof(UnityEngine.RenderTexture)); + UnityEngine.Material _mat = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + + UnityEngine.Graphics.Blit( _source, _dest, _mat ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Texture _source = (UnityEngine.Texture)translator.GetObject(L, 1, typeof(UnityEngine.Texture)); + UnityEngine.RenderTexture _dest = (UnityEngine.RenderTexture)translator.GetObject(L, 2, typeof(UnityEngine.RenderTexture)); + UnityEngine.Material _mat = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + int _pass = LuaAPI.xlua_tointeger(L, 4); + + UnityEngine.Graphics.Blit( _source, _dest, _mat, _pass ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Texture _source = (UnityEngine.Texture)translator.GetObject(L, 1, typeof(UnityEngine.Texture)); + UnityEngine.RenderTexture _dest = (UnityEngine.RenderTexture)translator.GetObject(L, 2, typeof(UnityEngine.RenderTexture)); + UnityEngine.Material _mat = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + int _pass = LuaAPI.xlua_tointeger(L, 4); + int _destDepthSlice = LuaAPI.xlua_tointeger(L, 5); + + UnityEngine.Graphics.Blit( _source, _dest, _mat, _pass, _destDepthSlice ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Texture _source = (UnityEngine.Texture)translator.GetObject(L, 1, typeof(UnityEngine.Texture)); + UnityEngine.RenderTexture _dest = (UnityEngine.RenderTexture)translator.GetObject(L, 2, typeof(UnityEngine.RenderTexture)); + UnityEngine.Vector2 _scale;translator.Get(L, 3, out _scale); + UnityEngine.Vector2 _offset;translator.Get(L, 4, out _offset); + + UnityEngine.Graphics.Blit( _source, _dest, _scale, _offset ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Texture _source = (UnityEngine.Texture)translator.GetObject(L, 1, typeof(UnityEngine.Texture)); + UnityEngine.RenderTexture _dest = (UnityEngine.RenderTexture)translator.GetObject(L, 2, typeof(UnityEngine.RenderTexture)); + UnityEngine.Vector2 _scale;translator.Get(L, 3, out _scale); + UnityEngine.Vector2 _offset;translator.Get(L, 4, out _offset); + int _sourceDepthSlice = LuaAPI.xlua_tointeger(L, 5); + int _destDepthSlice = LuaAPI.xlua_tointeger(L, 6); + + UnityEngine.Graphics.Blit( _source, _dest, _scale, _offset, _sourceDepthSlice, _destDepthSlice ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Graphics.Blit!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_BlitMultiTap_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count >= 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 4) || translator.Assignable(L, 4))) + { + UnityEngine.Texture _source = (UnityEngine.Texture)translator.GetObject(L, 1, typeof(UnityEngine.Texture)); + UnityEngine.RenderTexture _dest = (UnityEngine.RenderTexture)translator.GetObject(L, 2, typeof(UnityEngine.RenderTexture)); + UnityEngine.Material _mat = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + UnityEngine.Vector2[] _offsets = translator.GetParams(L, 4); + + UnityEngine.Graphics.BlitMultiTap( _source, _dest, _mat, _offsets ); + + + + return 0; + } + if(gen_param_count >= 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 5) || translator.Assignable(L, 5))) + { + UnityEngine.Texture _source = (UnityEngine.Texture)translator.GetObject(L, 1, typeof(UnityEngine.Texture)); + UnityEngine.RenderTexture _dest = (UnityEngine.RenderTexture)translator.GetObject(L, 2, typeof(UnityEngine.RenderTexture)); + UnityEngine.Material _mat = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + int _destDepthSlice = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.Vector2[] _offsets = translator.GetParams(L, 5); + + UnityEngine.Graphics.BlitMultiTap( _source, _dest, _mat, _destDepthSlice, _offsets ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Graphics.BlitMultiTap!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearRandomWriteTargets_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + UnityEngine.Graphics.ClearRandomWriteTargets( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ExecuteCommandBuffer_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Rendering.CommandBuffer _buffer = (UnityEngine.Rendering.CommandBuffer)translator.GetObject(L, 1, typeof(UnityEngine.Rendering.CommandBuffer)); + + UnityEngine.Graphics.ExecuteCommandBuffer( _buffer ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ExecuteCommandBufferAsync_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Rendering.CommandBuffer _buffer = (UnityEngine.Rendering.CommandBuffer)translator.GetObject(L, 1, typeof(UnityEngine.Rendering.CommandBuffer)); + UnityEngine.Rendering.ComputeQueueType _queueType;translator.Get(L, 2, out _queueType); + + UnityEngine.Graphics.ExecuteCommandBufferAsync( _buffer, _queueType ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_activeColorBuffer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Graphics.activeColorBuffer); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_activeDepthBuffer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Graphics.activeDepthBuffer); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_activeColorGamut(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Graphics.activeColorGamut); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_activeTier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Graphics.activeTier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preserveFramebufferAlpha(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Graphics.preserveFramebufferAlpha); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_minOpenGLESVersion(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Graphics.minOpenGLESVersion); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_activeTier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + UnityEngine.Rendering.GraphicsTier gen_value;translator.Get(L, 1, out gen_value); + UnityEngine.Graphics.activeTier = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_InputWrap.cs b/Assets/XLua/Gen/UnityEngine_InputWrap.cs new file mode 100644 index 000000000..27b8ec77d --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_InputWrap.cs @@ -0,0 +1,952 @@ +#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 UnityEngineInputWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Input); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 16, 26, 6); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetAxis", _m_GetAxis_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetAxisRaw", _m_GetAxisRaw_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetButton", _m_GetButton_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetButtonDown", _m_GetButtonDown_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetButtonUp", _m_GetButtonUp_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetMouseButton", _m_GetMouseButton_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetMouseButtonDown", _m_GetMouseButtonDown_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetMouseButtonUp", _m_GetMouseButtonUp_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ResetInputAxes", _m_ResetInputAxes_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetJoystickNames", _m_GetJoystickNames_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetTouch", _m_GetTouch_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetAccelerationEvent", _m_GetAccelerationEvent_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetKey", _m_GetKey_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetKeyUp", _m_GetKeyUp_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetKeyDown", _m_GetKeyDown_xlua_st_); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "simulateMouseWithTouches", _g_get_simulateMouseWithTouches); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "anyKey", _g_get_anyKey); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "anyKeyDown", _g_get_anyKeyDown); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "inputString", _g_get_inputString); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "mousePosition", _g_get_mousePosition); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "mouseScrollDelta", _g_get_mouseScrollDelta); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "imeCompositionMode", _g_get_imeCompositionMode); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "compositionString", _g_get_compositionString); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "imeIsSelected", _g_get_imeIsSelected); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "compositionCursorPos", _g_get_compositionCursorPos); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "mousePresent", _g_get_mousePresent); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "touchCount", _g_get_touchCount); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "touchPressureSupported", _g_get_touchPressureSupported); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "stylusTouchSupported", _g_get_stylusTouchSupported); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "touchSupported", _g_get_touchSupported); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "multiTouchEnabled", _g_get_multiTouchEnabled); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "deviceOrientation", _g_get_deviceOrientation); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "acceleration", _g_get_acceleration); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "compensateSensors", _g_get_compensateSensors); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "accelerationEventCount", _g_get_accelerationEventCount); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "backButtonLeavesApp", _g_get_backButtonLeavesApp); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "location", _g_get_location); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "compass", _g_get_compass); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "gyro", _g_get_gyro); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "touches", _g_get_touches); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "accelerationEvents", _g_get_accelerationEvents); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "simulateMouseWithTouches", _s_set_simulateMouseWithTouches); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "imeCompositionMode", _s_set_imeCompositionMode); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "compositionCursorPos", _s_set_compositionCursorPos); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "multiTouchEnabled", _s_set_multiTouchEnabled); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "compensateSensors", _s_set_compensateSensors); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "backButtonLeavesApp", _s_set_backButtonLeavesApp); + + + 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 UnityEngine.Input(); + 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 UnityEngine.Input constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetAxis_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _axisName = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.Input.GetAxis( _axisName ); + LuaAPI.lua_pushnumber(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_GetAxisRaw_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _axisName = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.Input.GetAxisRaw( _axisName ); + LuaAPI.lua_pushnumber(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_GetButton_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _buttonName = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.Input.GetButton( _buttonName ); + 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_GetButtonDown_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _buttonName = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.Input.GetButtonDown( _buttonName ); + 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_GetButtonUp_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _buttonName = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.Input.GetButtonUp( _buttonName ); + 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_GetMouseButton_xlua_st_(RealStatePtr L) + { + try { + + + + + { + int _button = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = UnityEngine.Input.GetMouseButton( _button ); + 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_GetMouseButtonDown_xlua_st_(RealStatePtr L) + { + try { + + + + + { + int _button = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = UnityEngine.Input.GetMouseButtonDown( _button ); + 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_GetMouseButtonUp_xlua_st_(RealStatePtr L) + { + try { + + + + + { + int _button = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = UnityEngine.Input.GetMouseButtonUp( _button ); + 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_ResetInputAxes_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + UnityEngine.Input.ResetInputAxes( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetJoystickNames_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = UnityEngine.Input.GetJoystickNames( ); + 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_GetTouch_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + int _index = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = UnityEngine.Input.GetTouch( _index ); + 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_GetAccelerationEvent_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + int _index = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = UnityEngine.Input.GetAccelerationEvent( _index ); + 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_GetKey_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + UnityEngine.KeyCode _key;translator.Get(L, 1, out _key); + + var gen_ret = UnityEngine.Input.GetKey( _key ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.Input.GetKey( _name ); + LuaAPI.lua_pushboolean(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 UnityEngine.Input.GetKey!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetKeyUp_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + UnityEngine.KeyCode _key;translator.Get(L, 1, out _key); + + var gen_ret = UnityEngine.Input.GetKeyUp( _key ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.Input.GetKeyUp( _name ); + LuaAPI.lua_pushboolean(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 UnityEngine.Input.GetKeyUp!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetKeyDown_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + UnityEngine.KeyCode _key;translator.Get(L, 1, out _key); + + var gen_ret = UnityEngine.Input.GetKeyDown( _key ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.Input.GetKeyDown( _name ); + LuaAPI.lua_pushboolean(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 UnityEngine.Input.GetKeyDown!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_simulateMouseWithTouches(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Input.simulateMouseWithTouches); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_anyKey(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Input.anyKey); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_anyKeyDown(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Input.anyKeyDown); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_inputString(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, UnityEngine.Input.inputString); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mousePosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineVector3(L, UnityEngine.Input.mousePosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mouseScrollDelta(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineVector2(L, UnityEngine.Input.mouseScrollDelta); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_imeCompositionMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Input.imeCompositionMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_compositionString(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, UnityEngine.Input.compositionString); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_imeIsSelected(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Input.imeIsSelected); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_compositionCursorPos(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineVector2(L, UnityEngine.Input.compositionCursorPos); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mousePresent(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Input.mousePresent); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_touchCount(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.Input.touchCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_touchPressureSupported(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Input.touchPressureSupported); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_stylusTouchSupported(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Input.stylusTouchSupported); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_touchSupported(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Input.touchSupported); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_multiTouchEnabled(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Input.multiTouchEnabled); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_deviceOrientation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Input.deviceOrientation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_acceleration(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineVector3(L, UnityEngine.Input.acceleration); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_compensateSensors(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Input.compensateSensors); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_accelerationEventCount(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.Input.accelerationEventCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_backButtonLeavesApp(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Input.backButtonLeavesApp); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_location(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Input.location); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_compass(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Input.compass); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_gyro(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Input.gyro); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_touches(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Input.touches); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_accelerationEvents(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Input.accelerationEvents); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_simulateMouseWithTouches(RealStatePtr L) + { + try { + + UnityEngine.Input.simulateMouseWithTouches = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_imeCompositionMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + UnityEngine.IMECompositionMode gen_value;translator.Get(L, 1, out gen_value); + UnityEngine.Input.imeCompositionMode = 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_compositionCursorPos(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + UnityEngine.Vector2 gen_value;translator.Get(L, 1, out gen_value); + UnityEngine.Input.compositionCursorPos = 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_multiTouchEnabled(RealStatePtr L) + { + try { + + UnityEngine.Input.multiTouchEnabled = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_compensateSensors(RealStatePtr L) + { + try { + + UnityEngine.Input.compensateSensors = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_backButtonLeavesApp(RealStatePtr L) + { + try { + + UnityEngine.Input.backButtonLeavesApp = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_KeyframeWrap.cs b/Assets/XLua/Gen/UnityEngine_KeyframeWrap.cs new file mode 100644 index 000000000..1354607dd --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_KeyframeWrap.cs @@ -0,0 +1,350 @@ +#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 UnityEngineKeyframeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Keyframe); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 7, 7); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "time", _g_get_time); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "value", _g_get_value); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "inTangent", _g_get_inTangent); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "outTangent", _g_get_outTangent); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "inWeight", _g_get_inWeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "outWeight", _g_get_outWeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "weightedMode", _g_get_weightedMode); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "time", _s_set_time); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "value", _s_set_value); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "inTangent", _s_set_inTangent); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "outTangent", _s_set_outTangent); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "inWeight", _s_set_inWeight); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "outWeight", _s_set_outWeight); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "weightedMode", _s_set_weightedMode); + + + 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 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _time = (float)LuaAPI.lua_tonumber(L, 2); + float _value = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = new UnityEngine.Keyframe(_time, _value); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 5 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + float _time = (float)LuaAPI.lua_tonumber(L, 2); + float _value = (float)LuaAPI.lua_tonumber(L, 3); + float _inTangent = (float)LuaAPI.lua_tonumber(L, 4); + float _outTangent = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = new UnityEngine.Keyframe(_time, _value, _inTangent, _outTangent); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 7 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)) + { + float _time = (float)LuaAPI.lua_tonumber(L, 2); + float _value = (float)LuaAPI.lua_tonumber(L, 3); + float _inTangent = (float)LuaAPI.lua_tonumber(L, 4); + float _outTangent = (float)LuaAPI.lua_tonumber(L, 5); + float _inWeight = (float)LuaAPI.lua_tonumber(L, 6); + float _outWeight = (float)LuaAPI.lua_tonumber(L, 7); + + var gen_ret = new UnityEngine.Keyframe(_time, _value, _inTangent, _outTangent, _inWeight, _outWeight); + translator.Push(L, gen_ret); + + return 1; + } + + if (LuaAPI.lua_gettop(L) == 1) + { + translator.Push(L, default(UnityEngine.Keyframe)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Keyframe constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_time(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Keyframe gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.time); + } 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); + + UnityEngine.Keyframe gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(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_inTangent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Keyframe gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.inTangent); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_outTangent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Keyframe gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.outTangent); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_inWeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Keyframe gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.inWeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_outWeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Keyframe gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.outWeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_weightedMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Keyframe gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.weightedMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_time(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Keyframe gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.time = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } 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); + + UnityEngine.Keyframe gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.value = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_inTangent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Keyframe gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.inTangent = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_outTangent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Keyframe gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.outTangent = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_inWeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Keyframe gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.inWeight = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_outWeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Keyframe gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.outWeight = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_weightedMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Keyframe gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.WeightedMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.weightedMode = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_LayerMaskWrap.cs b/Assets/XLua/Gen/UnityEngine_LayerMaskWrap.cs new file mode 100644 index 000000000..139ba35df --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_LayerMaskWrap.cs @@ -0,0 +1,195 @@ +#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 UnityEngineLayerMaskWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.LayerMask); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 1, 1); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "value", _g_get_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, 4, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LayerToName", _m_LayerToName_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "NameToLayer", _m_NameToLayer_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetMask", _m_GetMask_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) + { + translator.Push(L, default(UnityEngine.LayerMask)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.LayerMask constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LayerToName_xlua_st_(RealStatePtr L) + { + try { + + + + + { + int _layer = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = UnityEngine.LayerMask.LayerToName( _layer ); + 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 _m_NameToLayer_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _layerName = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.LayerMask.NameToLayer( _layerName ); + 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_GetMask_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string[] _layerNames = translator.GetParams(L, 1); + + var gen_ret = UnityEngine.LayerMask.GetMask( _layerNames ); + 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 _g_get_value(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LayerMask gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(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); + + UnityEngine.LayerMask gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.value = LuaAPI.xlua_tointeger(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_LightProbesWrap.cs b/Assets/XLua/Gen/UnityEngine_LightProbesWrap.cs new file mode 100644 index 000000000..7aee5a4df --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_LightProbesWrap.cs @@ -0,0 +1,327 @@ +#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 UnityEngineLightProbesWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.LightProbes); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 4, 1); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "positions", _g_get_positions); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bakedProbes", _g_get_bakedProbes); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "count", _g_get_count); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "cellCount", _g_get_cellCount); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "bakedProbes", _s_set_bakedProbes); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 7, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Tetrahedralize", _m_Tetrahedralize_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "TetrahedralizeAsync", _m_TetrahedralizeAsync_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetInterpolatedProbe", _m_GetInterpolatedProbe_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CalculateInterpolatedLightAndOcclusionProbes", _m_CalculateInterpolatedLightAndOcclusionProbes_xlua_st_); + + Utils.RegisterFunc(L, Utils.CLS_IDX, "tetrahedralizationCompleted", _e_tetrahedralizationCompleted); + Utils.RegisterFunc(L, Utils.CLS_IDX, "needsRetetrahedralization", _e_needsRetetrahedralization); + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "UnityEngine.LightProbes does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Tetrahedralize_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + UnityEngine.LightProbes.Tetrahedralize( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TetrahedralizeAsync_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + UnityEngine.LightProbes.TetrahedralizeAsync( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetInterpolatedProbe_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector3 _position;translator.Get(L, 1, out _position); + UnityEngine.Renderer _renderer = (UnityEngine.Renderer)translator.GetObject(L, 2, typeof(UnityEngine.Renderer)); + UnityEngine.Rendering.SphericalHarmonicsL2 _probe; + + UnityEngine.LightProbes.GetInterpolatedProbe( _position, _renderer, out _probe ); + translator.Push(L, _probe); + + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalculateInterpolatedLightAndOcclusionProbes_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3[] _positions = (UnityEngine.Vector3[])translator.GetObject(L, 1, typeof(UnityEngine.Vector3[])); + UnityEngine.Rendering.SphericalHarmonicsL2[] _lightProbes = (UnityEngine.Rendering.SphericalHarmonicsL2[])translator.GetObject(L, 2, typeof(UnityEngine.Rendering.SphericalHarmonicsL2[])); + UnityEngine.Vector4[] _occlusionProbes = (UnityEngine.Vector4[])translator.GetObject(L, 3, typeof(UnityEngine.Vector4[])); + + UnityEngine.LightProbes.CalculateInterpolatedLightAndOcclusionProbes( _positions, _lightProbes, _occlusionProbes ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable>(L, 1)&& translator.Assignable>(L, 2)&& translator.Assignable>(L, 3)) + { + System.Collections.Generic.List _positions = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _lightProbes = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + System.Collections.Generic.List _occlusionProbes = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + UnityEngine.LightProbes.CalculateInterpolatedLightAndOcclusionProbes( _positions, _lightProbes, _occlusionProbes ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.LightProbes.CalculateInterpolatedLightAndOcclusionProbes!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_positions(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LightProbes gen_to_be_invoked = (UnityEngine.LightProbes)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.positions); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bakedProbes(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LightProbes gen_to_be_invoked = (UnityEngine.LightProbes)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.bakedProbes); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_count(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LightProbes gen_to_be_invoked = (UnityEngine.LightProbes)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.count); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cellCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LightProbes gen_to_be_invoked = (UnityEngine.LightProbes)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.cellCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_bakedProbes(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LightProbes gen_to_be_invoked = (UnityEngine.LightProbes)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.bakedProbes = (UnityEngine.Rendering.SphericalHarmonicsL2[])translator.GetObject(L, 2, typeof(UnityEngine.Rendering.SphericalHarmonicsL2[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_tetrahedralizationCompleted(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + UnityEngine.LightProbes.tetrahedralizationCompleted += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + UnityEngine.LightProbes.tetrahedralizationCompleted -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.LightProbes.tetrahedralizationCompleted!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_needsRetetrahedralization(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + UnityEngine.LightProbes.needsRetetrahedralization += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + UnityEngine.LightProbes.needsRetetrahedralization -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.LightProbes.needsRetetrahedralization!"); + } + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_LightWrap.cs b/Assets/XLua/Gen/UnityEngine_LightWrap.cs new file mode 100644 index 000000000..431c5cbba --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_LightWrap.cs @@ -0,0 +1,1462 @@ +#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; +using DG.Tweening; + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class UnityEngineLightWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Light); + Utils.BeginObjectRegister(type, L, translator, 0, 11, 32, 31); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Reset", _m_Reset); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddCommandBuffer", _m_AddCommandBuffer); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddCommandBufferAsync", _m_AddCommandBufferAsync); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveCommandBuffer", _m_RemoveCommandBuffer); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveCommandBuffers", _m_RemoveCommandBuffers); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveAllCommandBuffers", _m_RemoveAllCommandBuffers); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetCommandBuffers", _m_GetCommandBuffers); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOColor", _m_DOColor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOIntensity", _m_DOIntensity); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOShadowStrength", _m_DOShadowStrength); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOBlendableColor", _m_DOBlendableColor); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "type", _g_get_type); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "shape", _g_get_shape); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "spotAngle", _g_get_spotAngle); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "innerSpotAngle", _g_get_innerSpotAngle); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "color", _g_get_color); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "colorTemperature", _g_get_colorTemperature); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "useColorTemperature", _g_get_useColorTemperature); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "intensity", _g_get_intensity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bounceIntensity", _g_get_bounceIntensity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "useBoundingSphereOverride", _g_get_useBoundingSphereOverride); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "boundingSphereOverride", _g_get_boundingSphereOverride); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "useViewFrustumForShadowCasterCull", _g_get_useViewFrustumForShadowCasterCull); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "shadowCustomResolution", _g_get_shadowCustomResolution); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "shadowBias", _g_get_shadowBias); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "shadowNormalBias", _g_get_shadowNormalBias); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "shadowNearPlane", _g_get_shadowNearPlane); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "useShadowMatrixOverride", _g_get_useShadowMatrixOverride); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "shadowMatrixOverride", _g_get_shadowMatrixOverride); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "range", _g_get_range); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "flare", _g_get_flare); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bakingOutput", _g_get_bakingOutput); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "cullingMask", _g_get_cullingMask); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "renderingLayerMask", _g_get_renderingLayerMask); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lightShadowCasterMode", _g_get_lightShadowCasterMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "shadows", _g_get_shadows); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "shadowStrength", _g_get_shadowStrength); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "shadowResolution", _g_get_shadowResolution); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "layerShadowCullDistances", _g_get_layerShadowCullDistances); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "cookieSize", _g_get_cookieSize); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "cookie", _g_get_cookie); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "renderMode", _g_get_renderMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "commandBufferCount", _g_get_commandBufferCount); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "type", _s_set_type); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "shape", _s_set_shape); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "spotAngle", _s_set_spotAngle); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "innerSpotAngle", _s_set_innerSpotAngle); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "color", _s_set_color); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "colorTemperature", _s_set_colorTemperature); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "useColorTemperature", _s_set_useColorTemperature); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "intensity", _s_set_intensity); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "bounceIntensity", _s_set_bounceIntensity); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "useBoundingSphereOverride", _s_set_useBoundingSphereOverride); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "boundingSphereOverride", _s_set_boundingSphereOverride); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "useViewFrustumForShadowCasterCull", _s_set_useViewFrustumForShadowCasterCull); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "shadowCustomResolution", _s_set_shadowCustomResolution); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "shadowBias", _s_set_shadowBias); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "shadowNormalBias", _s_set_shadowNormalBias); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "shadowNearPlane", _s_set_shadowNearPlane); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "useShadowMatrixOverride", _s_set_useShadowMatrixOverride); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "shadowMatrixOverride", _s_set_shadowMatrixOverride); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "range", _s_set_range); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "flare", _s_set_flare); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "bakingOutput", _s_set_bakingOutput); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "cullingMask", _s_set_cullingMask); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "renderingLayerMask", _s_set_renderingLayerMask); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "lightShadowCasterMode", _s_set_lightShadowCasterMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "shadows", _s_set_shadows); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "shadowStrength", _s_set_shadowStrength); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "shadowResolution", _s_set_shadowResolution); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "layerShadowCullDistances", _s_set_layerShadowCullDistances); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "cookieSize", _s_set_cookieSize); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "cookie", _s_set_cookie); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "renderMode", _s_set_renderMode); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetLights", _m_GetLights_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 UnityEngine.Light(); + 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 UnityEngine.Light constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Reset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Reset( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddCommandBuffer(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Rendering.LightEvent _evt;translator.Get(L, 2, out _evt); + UnityEngine.Rendering.CommandBuffer _buffer = (UnityEngine.Rendering.CommandBuffer)translator.GetObject(L, 3, typeof(UnityEngine.Rendering.CommandBuffer)); + + gen_to_be_invoked.AddCommandBuffer( _evt, _buffer ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Rendering.LightEvent _evt;translator.Get(L, 2, out _evt); + UnityEngine.Rendering.CommandBuffer _buffer = (UnityEngine.Rendering.CommandBuffer)translator.GetObject(L, 3, typeof(UnityEngine.Rendering.CommandBuffer)); + UnityEngine.Rendering.ShadowMapPass _shadowPassMask;translator.Get(L, 4, out _shadowPassMask); + + gen_to_be_invoked.AddCommandBuffer( _evt, _buffer, _shadowPassMask ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Light.AddCommandBuffer!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddCommandBufferAsync(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Rendering.LightEvent _evt;translator.Get(L, 2, out _evt); + UnityEngine.Rendering.CommandBuffer _buffer = (UnityEngine.Rendering.CommandBuffer)translator.GetObject(L, 3, typeof(UnityEngine.Rendering.CommandBuffer)); + UnityEngine.Rendering.ComputeQueueType _queueType;translator.Get(L, 4, out _queueType); + + gen_to_be_invoked.AddCommandBufferAsync( _evt, _buffer, _queueType ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)) + { + UnityEngine.Rendering.LightEvent _evt;translator.Get(L, 2, out _evt); + UnityEngine.Rendering.CommandBuffer _buffer = (UnityEngine.Rendering.CommandBuffer)translator.GetObject(L, 3, typeof(UnityEngine.Rendering.CommandBuffer)); + UnityEngine.Rendering.ShadowMapPass _shadowPassMask;translator.Get(L, 4, out _shadowPassMask); + UnityEngine.Rendering.ComputeQueueType _queueType;translator.Get(L, 5, out _queueType); + + gen_to_be_invoked.AddCommandBufferAsync( _evt, _buffer, _shadowPassMask, _queueType ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Light.AddCommandBufferAsync!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveCommandBuffer(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Rendering.LightEvent _evt;translator.Get(L, 2, out _evt); + UnityEngine.Rendering.CommandBuffer _buffer = (UnityEngine.Rendering.CommandBuffer)translator.GetObject(L, 3, typeof(UnityEngine.Rendering.CommandBuffer)); + + gen_to_be_invoked.RemoveCommandBuffer( _evt, _buffer ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveCommandBuffers(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Rendering.LightEvent _evt;translator.Get(L, 2, out _evt); + + gen_to_be_invoked.RemoveCommandBuffers( _evt ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveAllCommandBuffers(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RemoveAllCommandBuffers( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetCommandBuffers(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Rendering.LightEvent _evt;translator.Get(L, 2, out _evt); + + var gen_ret = gen_to_be_invoked.GetCommandBuffers( _evt ); + 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_GetLights_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.LightType _type;translator.Get(L, 1, out _type); + int _layer = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = UnityEngine.Light.GetLights( _type, _layer ); + 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_DOColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Color _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOColor( _endValue, _duration ); + 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_DOIntensity(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + + + + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOIntensity( _endValue, _duration ); + 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_DOShadowStrength(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + + + + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOShadowStrength( _endValue, _duration ); + 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_DOBlendableColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Color _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOBlendableColor( _endValue, _duration ); + 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_type(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.type); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_shape(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.shape); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_spotAngle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.spotAngle); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_innerSpotAngle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.innerSpotAngle); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_color(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineColor(L, gen_to_be_invoked.color); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_colorTemperature(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.colorTemperature); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_useColorTemperature(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.useColorTemperature); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_intensity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.intensity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bounceIntensity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.bounceIntensity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_useBoundingSphereOverride(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.useBoundingSphereOverride); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_boundingSphereOverride(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector4(L, gen_to_be_invoked.boundingSphereOverride); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_useViewFrustumForShadowCasterCull(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.useViewFrustumForShadowCasterCull); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_shadowCustomResolution(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.shadowCustomResolution); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_shadowBias(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.shadowBias); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_shadowNormalBias(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.shadowNormalBias); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_shadowNearPlane(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.shadowNearPlane); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_useShadowMatrixOverride(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.useShadowMatrixOverride); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_shadowMatrixOverride(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.shadowMatrixOverride); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_range(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.range); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_flare(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.flare); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bakingOutput(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.bakingOutput); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cullingMask(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.cullingMask); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_renderingLayerMask(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.renderingLayerMask); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lightShadowCasterMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.lightShadowCasterMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_shadows(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.shadows); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_shadowStrength(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.shadowStrength); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_shadowResolution(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineRenderingLightShadowResolution(L, gen_to_be_invoked.shadowResolution); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_layerShadowCullDistances(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.layerShadowCullDistances); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cookieSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.cookieSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cookie(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.cookie); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_renderMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.renderMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_commandBufferCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.commandBufferCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_type(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + UnityEngine.LightType gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.type = 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_shape(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + UnityEngine.LightShape gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.shape = 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_spotAngle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.spotAngle = (float)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_innerSpotAngle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.innerSpotAngle = (float)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_color(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + UnityEngine.Color gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.color = 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_colorTemperature(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.colorTemperature = (float)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_useColorTemperature(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.useColorTemperature = 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_intensity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.intensity = (float)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_bounceIntensity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.bounceIntensity = (float)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_useBoundingSphereOverride(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.useBoundingSphereOverride = 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_boundingSphereOverride(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + UnityEngine.Vector4 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.boundingSphereOverride = 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_useViewFrustumForShadowCasterCull(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.useViewFrustumForShadowCasterCull = 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_shadowCustomResolution(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.shadowCustomResolution = 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_shadowBias(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.shadowBias = (float)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_shadowNormalBias(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.shadowNormalBias = (float)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_shadowNearPlane(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.shadowNearPlane = (float)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_useShadowMatrixOverride(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.useShadowMatrixOverride = 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_shadowMatrixOverride(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + UnityEngine.Matrix4x4 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.shadowMatrixOverride = 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_range(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.range = (float)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_flare(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.flare = (UnityEngine.Flare)translator.GetObject(L, 2, typeof(UnityEngine.Flare)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_bakingOutput(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + UnityEngine.LightBakingOutput gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.bakingOutput = 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_cullingMask(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.cullingMask = 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_renderingLayerMask(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.renderingLayerMask = 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_lightShadowCasterMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + UnityEngine.LightShadowCasterMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.lightShadowCasterMode = 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_shadows(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + UnityEngine.LightShadows gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.shadows = 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_shadowStrength(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.shadowStrength = (float)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_shadowResolution(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + UnityEngine.Rendering.LightShadowResolution gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.shadowResolution = 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_layerShadowCullDistances(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.layerShadowCullDistances = (float[])translator.GetObject(L, 2, typeof(float[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_cookieSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.cookieSize = (float)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_cookie(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.cookie = (UnityEngine.Texture)translator.GetObject(L, 2, typeof(UnityEngine.Texture)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_renderMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Light gen_to_be_invoked = (UnityEngine.Light)translator.FastGetCSObj(L, 1); + UnityEngine.LightRenderMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.renderMode = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_LightmapDataWrap.cs b/Assets/XLua/Gen/UnityEngine_LightmapDataWrap.cs new file mode 100644 index 000000000..bfb127621 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_LightmapDataWrap.cs @@ -0,0 +1,177 @@ +#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 UnityEngineLightmapDataWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.LightmapData); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 3, 3); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lightmapColor", _g_get_lightmapColor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lightmapDir", _g_get_lightmapDir); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "shadowMask", _g_get_shadowMask); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "lightmapColor", _s_set_lightmapColor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "lightmapDir", _s_set_lightmapDir); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "shadowMask", _s_set_shadowMask); + + + 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 UnityEngine.LightmapData(); + 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 UnityEngine.LightmapData constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lightmapColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LightmapData gen_to_be_invoked = (UnityEngine.LightmapData)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.lightmapColor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lightmapDir(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LightmapData gen_to_be_invoked = (UnityEngine.LightmapData)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.lightmapDir); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_shadowMask(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LightmapData gen_to_be_invoked = (UnityEngine.LightmapData)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.shadowMask); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_lightmapColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LightmapData gen_to_be_invoked = (UnityEngine.LightmapData)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.lightmapColor = (UnityEngine.Texture2D)translator.GetObject(L, 2, typeof(UnityEngine.Texture2D)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_lightmapDir(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LightmapData gen_to_be_invoked = (UnityEngine.LightmapData)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.lightmapDir = (UnityEngine.Texture2D)translator.GetObject(L, 2, typeof(UnityEngine.Texture2D)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_shadowMask(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LightmapData gen_to_be_invoked = (UnityEngine.LightmapData)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.shadowMask = (UnityEngine.Texture2D)translator.GetObject(L, 2, typeof(UnityEngine.Texture2D)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_LightmapSettingsWrap.cs b/Assets/XLua/Gen/UnityEngine_LightmapSettingsWrap.cs new file mode 100644 index 000000000..bbd2acece --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_LightmapSettingsWrap.cs @@ -0,0 +1,149 @@ +#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 UnityEngineLightmapSettingsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.LightmapSettings); + 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, 3, 3); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "lightmaps", _g_get_lightmaps); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "lightmapsMode", _g_get_lightmapsMode); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "lightProbes", _g_get_lightProbes); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "lightmaps", _s_set_lightmaps); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "lightmapsMode", _s_set_lightmapsMode); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "lightProbes", _s_set_lightProbes); + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "UnityEngine.LightmapSettings does not have a constructor!"); + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lightmaps(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.LightmapSettings.lightmaps); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lightmapsMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.LightmapSettings.lightmapsMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lightProbes(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.LightmapSettings.lightProbes); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_lightmaps(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + UnityEngine.LightmapSettings.lightmaps = (UnityEngine.LightmapData[])translator.GetObject(L, 1, typeof(UnityEngine.LightmapData[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_lightmapsMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + UnityEngine.LightmapsMode gen_value;translator.Get(L, 1, out gen_value); + UnityEngine.LightmapSettings.lightmapsMode = 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_lightProbes(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + UnityEngine.LightmapSettings.lightProbes = (UnityEngine.LightProbes)translator.GetObject(L, 1, typeof(UnityEngine.LightProbes)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_LineRendererWrap.cs b/Assets/XLua/Gen/UnityEngine_LineRendererWrap.cs new file mode 100644 index 000000000..eaa441654 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_LineRendererWrap.cs @@ -0,0 +1,881 @@ +#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; +using DG.Tweening; + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class UnityEngineLineRendererWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.LineRenderer); + Utils.BeginObjectRegister(type, L, translator, 0, 7, 16, 16); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPosition", _m_SetPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPosition", _m_GetPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Simplify", _m_Simplify); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "BakeMesh", _m_BakeMesh); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPositions", _m_GetPositions); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPositions", _m_SetPositions); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOColor", _m_DOColor); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startWidth", _g_get_startWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "endWidth", _g_get_endWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "widthMultiplier", _g_get_widthMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "numCornerVertices", _g_get_numCornerVertices); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "numCapVertices", _g_get_numCapVertices); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "useWorldSpace", _g_get_useWorldSpace); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "loop", _g_get_loop); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startColor", _g_get_startColor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "endColor", _g_get_endColor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "positionCount", _g_get_positionCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "shadowBias", _g_get_shadowBias); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "generateLightingData", _g_get_generateLightingData); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "textureMode", _g_get_textureMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "alignment", _g_get_alignment); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "widthCurve", _g_get_widthCurve); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "colorGradient", _g_get_colorGradient); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startWidth", _s_set_startWidth); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "endWidth", _s_set_endWidth); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "widthMultiplier", _s_set_widthMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "numCornerVertices", _s_set_numCornerVertices); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "numCapVertices", _s_set_numCapVertices); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "useWorldSpace", _s_set_useWorldSpace); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "loop", _s_set_loop); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startColor", _s_set_startColor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "endColor", _s_set_endColor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "positionCount", _s_set_positionCount); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "shadowBias", _s_set_shadowBias); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "generateLightingData", _s_set_generateLightingData); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "textureMode", _s_set_textureMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "alignment", _s_set_alignment); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "widthCurve", _s_set_widthCurve); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "colorGradient", _s_set_colorGradient); + + + 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 UnityEngine.LineRenderer(); + 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 UnityEngine.LineRenderer constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Vector3 _position;translator.Get(L, 3, out _position); + + gen_to_be_invoked.SetPosition( _index, _position ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetPosition( _index ); + translator.PushUnityEngineVector3(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_Simplify(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + + + + { + float _tolerance = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.Simplify( _tolerance ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_BakeMesh(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + bool _useTransform = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.BakeMesh( _mesh, _useTransform ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + + gen_to_be_invoked.BakeMesh( _mesh ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 3, typeof(UnityEngine.Camera)); + bool _useTransform = LuaAPI.lua_toboolean(L, 4); + + gen_to_be_invoked.BakeMesh( _mesh, _camera, _useTransform ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 3, typeof(UnityEngine.Camera)); + + gen_to_be_invoked.BakeMesh( _mesh, _camera ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.LineRenderer.BakeMesh!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetPositions(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3[] _positions = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + + var gen_ret = gen_to_be_invoked.GetPositions( _positions ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 2; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + Unity.Collections.NativeArray _positions;translator.Get(L, 2, out _positions); + + var gen_ret = gen_to_be_invoked.GetPositions( _positions ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 2; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + Unity.Collections.NativeSlice _positions;translator.Get(L, 2, out _positions); + + var gen_ret = gen_to_be_invoked.GetPositions( _positions ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.LineRenderer.GetPositions!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetPositions(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3[] _positions = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + + gen_to_be_invoked.SetPositions( _positions ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + Unity.Collections.NativeArray _positions;translator.Get(L, 2, out _positions); + + gen_to_be_invoked.SetPositions( _positions ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + Unity.Collections.NativeSlice _positions;translator.Get(L, 2, out _positions); + + gen_to_be_invoked.SetPositions( _positions ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.LineRenderer.SetPositions!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + + + + { + DG.Tweening.Color2 _startValue;translator.Get(L, 2, out _startValue); + DG.Tweening.Color2 _endValue;translator.Get(L, 3, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.DOColor( _startValue, _endValue, _duration ); + 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_startWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.startWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_endWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.endWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_widthMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.widthMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_numCornerVertices(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.numCornerVertices); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_numCapVertices(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.numCapVertices); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_useWorldSpace(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.useWorldSpace); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_loop(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.loop); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineColor(L, gen_to_be_invoked.startColor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_endColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineColor(L, gen_to_be_invoked.endColor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_positionCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.positionCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_shadowBias(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.shadowBias); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_generateLightingData(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.generateLightingData); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_textureMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.textureMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_alignment(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.alignment); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_widthCurve(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.widthCurve); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_colorGradient(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.colorGradient); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.startWidth = (float)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_endWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.endWidth = (float)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_widthMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.widthMultiplier = (float)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_numCornerVertices(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.numCornerVertices = 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_numCapVertices(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.numCapVertices = 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_useWorldSpace(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.useWorldSpace = 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_loop(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.loop = 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_startColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + UnityEngine.Color gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.startColor = 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_endColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + UnityEngine.Color gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.endColor = 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_positionCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.positionCount = 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_shadowBias(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.shadowBias = (float)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_generateLightingData(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.generateLightingData = 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_textureMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + UnityEngine.LineTextureMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.textureMode = 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_alignment(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + UnityEngine.LineAlignment gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.alignment = 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_widthCurve(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.widthCurve = (UnityEngine.AnimationCurve)translator.GetObject(L, 2, typeof(UnityEngine.AnimationCurve)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_colorGradient(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.LineRenderer gen_to_be_invoked = (UnityEngine.LineRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.colorGradient = (UnityEngine.Gradient)translator.GetObject(L, 2, typeof(UnityEngine.Gradient)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_MaterialPropertyBlockWrap.cs b/Assets/XLua/Gen/UnityEngine_MaterialPropertyBlockWrap.cs new file mode 100644 index 000000000..9791edd27 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_MaterialPropertyBlockWrap.cs @@ -0,0 +1,1913 @@ +#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 UnityEngineMaterialPropertyBlockWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.MaterialPropertyBlock); + Utils.BeginObjectRegister(type, L, translator, 0, 35, 1, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetInt", _m_SetInt); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetFloat", _m_SetFloat); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetInteger", _m_SetInteger); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetVector", _m_SetVector); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetColor", _m_SetColor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMatrix", _m_SetMatrix); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetBuffer", _m_SetBuffer); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTexture", _m_SetTexture); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetConstantBuffer", _m_SetConstantBuffer); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetFloatArray", _m_SetFloatArray); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetVectorArray", _m_SetVectorArray); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMatrixArray", _m_SetMatrixArray); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasProperty", _m_HasProperty); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasInt", _m_HasInt); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasFloat", _m_HasFloat); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasInteger", _m_HasInteger); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasTexture", _m_HasTexture); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasMatrix", _m_HasMatrix); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasVector", _m_HasVector); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasColor", _m_HasColor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasBuffer", _m_HasBuffer); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasConstantBuffer", _m_HasConstantBuffer); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetFloat", _m_GetFloat); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetInt", _m_GetInt); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetInteger", _m_GetInteger); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetVector", _m_GetVector); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetColor", _m_GetColor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetMatrix", _m_GetMatrix); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTexture", _m_GetTexture); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetFloatArray", _m_GetFloatArray); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetVectorArray", _m_GetVectorArray); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetMatrixArray", _m_GetMatrixArray); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CopySHCoefficientArraysFrom", _m_CopySHCoefficientArraysFrom); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CopyProbeOcclusionArrayFrom", _m_CopyProbeOcclusionArrayFrom); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isEmpty", _g_get_isEmpty); + + + + 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 UnityEngine.MaterialPropertyBlock(); + 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 UnityEngine.MaterialPropertyBlock constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Clear(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Clear( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetInt(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + int _value = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetInt( _nameID, _value ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + int _value = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetInt( _name, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.MaterialPropertyBlock.SetInt!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetFloat(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + float _value = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetFloat( _nameID, _value ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + float _value = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetFloat( _name, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.MaterialPropertyBlock.SetFloat!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetInteger(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + int _value = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetInteger( _nameID, _value ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + int _value = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetInteger( _name, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.MaterialPropertyBlock.SetInteger!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetVector(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Vector4 _value;translator.Get(L, 3, out _value); + + gen_to_be_invoked.SetVector( _nameID, _value ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + UnityEngine.Vector4 _value;translator.Get(L, 3, out _value); + + gen_to_be_invoked.SetVector( _name, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.MaterialPropertyBlock.SetVector!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Color _value;translator.Get(L, 3, out _value); + + gen_to_be_invoked.SetColor( _nameID, _value ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + UnityEngine.Color _value;translator.Get(L, 3, out _value); + + gen_to_be_invoked.SetColor( _name, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.MaterialPropertyBlock.SetColor!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMatrix(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Matrix4x4 _value;translator.Get(L, 3, out _value); + + gen_to_be_invoked.SetMatrix( _nameID, _value ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + UnityEngine.Matrix4x4 _value;translator.Get(L, 3, out _value); + + gen_to_be_invoked.SetMatrix( _name, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.MaterialPropertyBlock.SetMatrix!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetBuffer(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.ComputeBuffer _value = (UnityEngine.ComputeBuffer)translator.GetObject(L, 3, typeof(UnityEngine.ComputeBuffer)); + + gen_to_be_invoked.SetBuffer( _nameID, _value ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.GraphicsBuffer _value = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 3, typeof(UnityEngine.GraphicsBuffer)); + + gen_to_be_invoked.SetBuffer( _nameID, _value ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + UnityEngine.ComputeBuffer _value = (UnityEngine.ComputeBuffer)translator.GetObject(L, 3, typeof(UnityEngine.ComputeBuffer)); + + gen_to_be_invoked.SetBuffer( _name, _value ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + UnityEngine.GraphicsBuffer _value = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 3, typeof(UnityEngine.GraphicsBuffer)); + + gen_to_be_invoked.SetBuffer( _name, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.MaterialPropertyBlock.SetBuffer!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTexture(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Texture _value = (UnityEngine.Texture)translator.GetObject(L, 3, typeof(UnityEngine.Texture)); + + gen_to_be_invoked.SetTexture( _nameID, _value ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + UnityEngine.Texture _value = (UnityEngine.Texture)translator.GetObject(L, 3, typeof(UnityEngine.Texture)); + + gen_to_be_invoked.SetTexture( _name, _value ); + + + + return 0; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.RenderTexture _value = (UnityEngine.RenderTexture)translator.GetObject(L, 3, typeof(UnityEngine.RenderTexture)); + UnityEngine.Rendering.RenderTextureSubElement _element;translator.Get(L, 4, out _element); + + gen_to_be_invoked.SetTexture( _nameID, _value, _element ); + + + + return 0; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + string _name = LuaAPI.lua_tostring(L, 2); + UnityEngine.RenderTexture _value = (UnityEngine.RenderTexture)translator.GetObject(L, 3, typeof(UnityEngine.RenderTexture)); + UnityEngine.Rendering.RenderTextureSubElement _element;translator.Get(L, 4, out _element); + + gen_to_be_invoked.SetTexture( _name, _value, _element ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.MaterialPropertyBlock.SetTexture!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetConstantBuffer(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.ComputeBuffer _value = (UnityEngine.ComputeBuffer)translator.GetObject(L, 3, typeof(UnityEngine.ComputeBuffer)); + int _offset = LuaAPI.xlua_tointeger(L, 4); + int _size = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.SetConstantBuffer( _nameID, _value, _offset, _size ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.GraphicsBuffer _value = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 3, typeof(UnityEngine.GraphicsBuffer)); + int _offset = LuaAPI.xlua_tointeger(L, 4); + int _size = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.SetConstantBuffer( _nameID, _value, _offset, _size ); + + + + return 0; + } + if(gen_param_count == 5&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + string _name = LuaAPI.lua_tostring(L, 2); + UnityEngine.ComputeBuffer _value = (UnityEngine.ComputeBuffer)translator.GetObject(L, 3, typeof(UnityEngine.ComputeBuffer)); + int _offset = LuaAPI.xlua_tointeger(L, 4); + int _size = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.SetConstantBuffer( _name, _value, _offset, _size ); + + + + return 0; + } + if(gen_param_count == 5&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + string _name = LuaAPI.lua_tostring(L, 2); + UnityEngine.GraphicsBuffer _value = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 3, typeof(UnityEngine.GraphicsBuffer)); + int _offset = LuaAPI.xlua_tointeger(L, 4); + int _size = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.SetConstantBuffer( _name, _value, _offset, _size ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.MaterialPropertyBlock.SetConstantBuffer!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetFloatArray(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.SetFloatArray( _nameID, _values ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + float[] _values = (float[])translator.GetObject(L, 3, typeof(float[])); + + gen_to_be_invoked.SetFloatArray( _nameID, _values ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.SetFloatArray( _name, _values ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + float[] _values = (float[])translator.GetObject(L, 3, typeof(float[])); + + gen_to_be_invoked.SetFloatArray( _name, _values ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.MaterialPropertyBlock.SetFloatArray!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetVectorArray(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.SetVectorArray( _nameID, _values ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Vector4[] _values = (UnityEngine.Vector4[])translator.GetObject(L, 3, typeof(UnityEngine.Vector4[])); + + gen_to_be_invoked.SetVectorArray( _nameID, _values ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.SetVectorArray( _name, _values ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + UnityEngine.Vector4[] _values = (UnityEngine.Vector4[])translator.GetObject(L, 3, typeof(UnityEngine.Vector4[])); + + gen_to_be_invoked.SetVectorArray( _name, _values ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.MaterialPropertyBlock.SetVectorArray!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMatrixArray(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.SetMatrixArray( _nameID, _values ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Matrix4x4[] _values = (UnityEngine.Matrix4x4[])translator.GetObject(L, 3, typeof(UnityEngine.Matrix4x4[])); + + gen_to_be_invoked.SetMatrixArray( _nameID, _values ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.SetMatrixArray( _name, _values ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + UnityEngine.Matrix4x4[] _values = (UnityEngine.Matrix4x4[])translator.GetObject(L, 3, typeof(UnityEngine.Matrix4x4[])); + + gen_to_be_invoked.SetMatrixArray( _name, _values ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.MaterialPropertyBlock.SetMatrixArray!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasProperty(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.HasProperty( _nameID ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.HasProperty( _name ); + LuaAPI.lua_pushboolean(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 UnityEngine.MaterialPropertyBlock.HasProperty!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasInt(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.HasInt( _nameID ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.HasInt( _name ); + LuaAPI.lua_pushboolean(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 UnityEngine.MaterialPropertyBlock.HasInt!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasFloat(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.HasFloat( _nameID ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.HasFloat( _name ); + LuaAPI.lua_pushboolean(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 UnityEngine.MaterialPropertyBlock.HasFloat!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasInteger(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.HasInteger( _nameID ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.HasInteger( _name ); + LuaAPI.lua_pushboolean(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 UnityEngine.MaterialPropertyBlock.HasInteger!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasTexture(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.HasTexture( _nameID ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.HasTexture( _name ); + LuaAPI.lua_pushboolean(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 UnityEngine.MaterialPropertyBlock.HasTexture!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasMatrix(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.HasMatrix( _nameID ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.HasMatrix( _name ); + LuaAPI.lua_pushboolean(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 UnityEngine.MaterialPropertyBlock.HasMatrix!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasVector(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.HasVector( _nameID ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.HasVector( _name ); + LuaAPI.lua_pushboolean(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 UnityEngine.MaterialPropertyBlock.HasVector!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.HasColor( _nameID ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.HasColor( _name ); + LuaAPI.lua_pushboolean(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 UnityEngine.MaterialPropertyBlock.HasColor!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasBuffer(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.HasBuffer( _nameID ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.HasBuffer( _name ); + LuaAPI.lua_pushboolean(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 UnityEngine.MaterialPropertyBlock.HasBuffer!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasConstantBuffer(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.HasConstantBuffer( _nameID ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.HasConstantBuffer( _name ); + LuaAPI.lua_pushboolean(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 UnityEngine.MaterialPropertyBlock.HasConstantBuffer!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetFloat(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetFloat( _nameID ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetFloat( _name ); + LuaAPI.lua_pushnumber(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 UnityEngine.MaterialPropertyBlock.GetFloat!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetInt(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetInt( _nameID ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetInt( _name ); + LuaAPI.xlua_pushinteger(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 UnityEngine.MaterialPropertyBlock.GetInt!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetInteger(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetInteger( _nameID ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetInteger( _name ); + LuaAPI.xlua_pushinteger(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 UnityEngine.MaterialPropertyBlock.GetInteger!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetVector(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetVector( _nameID ); + translator.PushUnityEngineVector4(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetVector( _name ); + translator.PushUnityEngineVector4(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 UnityEngine.MaterialPropertyBlock.GetVector!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetColor( _nameID ); + translator.PushUnityEngineColor(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetColor( _name ); + translator.PushUnityEngineColor(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 UnityEngine.MaterialPropertyBlock.GetColor!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetMatrix(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetMatrix( _nameID ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetMatrix( _name ); + 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 UnityEngine.MaterialPropertyBlock.GetMatrix!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetTexture(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetTexture( _nameID ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetTexture( _name ); + 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 UnityEngine.MaterialPropertyBlock.GetTexture!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetFloatArray(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetFloatArray( _nameID ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetFloatArray( _name ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetFloatArray( _nameID, _values ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetFloatArray( _name, _values ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.MaterialPropertyBlock.GetFloatArray!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetVectorArray(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetVectorArray( _nameID ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetVectorArray( _name ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetVectorArray( _nameID, _values ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetVectorArray( _name, _values ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.MaterialPropertyBlock.GetVectorArray!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetMatrixArray(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetMatrixArray( _nameID ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetMatrixArray( _name ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetMatrixArray( _nameID, _values ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetMatrixArray( _name, _values ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.MaterialPropertyBlock.GetMatrixArray!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CopySHCoefficientArraysFrom(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.List _lightProbes = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.CopySHCoefficientArraysFrom( _lightProbes ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Rendering.SphericalHarmonicsL2[] _lightProbes = (UnityEngine.Rendering.SphericalHarmonicsL2[])translator.GetObject(L, 2, typeof(UnityEngine.Rendering.SphericalHarmonicsL2[])); + + gen_to_be_invoked.CopySHCoefficientArraysFrom( _lightProbes ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + System.Collections.Generic.List _lightProbes = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _sourceStart = LuaAPI.xlua_tointeger(L, 3); + int _destStart = LuaAPI.xlua_tointeger(L, 4); + int _count = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.CopySHCoefficientArraysFrom( _lightProbes, _sourceStart, _destStart, _count ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Rendering.SphericalHarmonicsL2[] _lightProbes = (UnityEngine.Rendering.SphericalHarmonicsL2[])translator.GetObject(L, 2, typeof(UnityEngine.Rendering.SphericalHarmonicsL2[])); + int _sourceStart = LuaAPI.xlua_tointeger(L, 3); + int _destStart = LuaAPI.xlua_tointeger(L, 4); + int _count = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.CopySHCoefficientArraysFrom( _lightProbes, _sourceStart, _destStart, _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.MaterialPropertyBlock.CopySHCoefficientArraysFrom!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CopyProbeOcclusionArrayFrom(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.List _occlusionProbes = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.CopyProbeOcclusionArrayFrom( _occlusionProbes ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector4[] _occlusionProbes = (UnityEngine.Vector4[])translator.GetObject(L, 2, typeof(UnityEngine.Vector4[])); + + gen_to_be_invoked.CopyProbeOcclusionArrayFrom( _occlusionProbes ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + System.Collections.Generic.List _occlusionProbes = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _sourceStart = LuaAPI.xlua_tointeger(L, 3); + int _destStart = LuaAPI.xlua_tointeger(L, 4); + int _count = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.CopyProbeOcclusionArrayFrom( _occlusionProbes, _sourceStart, _destStart, _count ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Vector4[] _occlusionProbes = (UnityEngine.Vector4[])translator.GetObject(L, 2, typeof(UnityEngine.Vector4[])); + int _sourceStart = LuaAPI.xlua_tointeger(L, 3); + int _destStart = LuaAPI.xlua_tointeger(L, 4); + int _count = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.CopyProbeOcclusionArrayFrom( _occlusionProbes, _sourceStart, _destStart, _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.MaterialPropertyBlock.CopyProbeOcclusionArrayFrom!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isEmpty(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.MaterialPropertyBlock gen_to_be_invoked = (UnityEngine.MaterialPropertyBlock)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isEmpty); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_MaterialWrap.cs b/Assets/XLua/Gen/UnityEngine_MaterialWrap.cs new file mode 100644 index 000000000..ede475c2c --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_MaterialWrap.cs @@ -0,0 +1,3897 @@ +#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; +using DG.Tweening; + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class UnityEngineMaterialWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Material); + Utils.BeginObjectRegister(type, L, translator, 0, 75, 12, 11); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetInt", _m_SetInt); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetFloat", _m_SetFloat); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetInteger", _m_SetInteger); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetColor", _m_SetColor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetVector", _m_SetVector); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMatrix", _m_SetMatrix); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTexture", _m_SetTexture); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetBuffer", _m_SetBuffer); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetConstantBuffer", _m_SetConstantBuffer); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetFloatArray", _m_SetFloatArray); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetColorArray", _m_SetColorArray); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetVectorArray", _m_SetVectorArray); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMatrixArray", _m_SetMatrixArray); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetInt", _m_GetInt); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetFloat", _m_GetFloat); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetInteger", _m_GetInteger); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetColor", _m_GetColor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetVector", _m_GetVector); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetMatrix", _m_GetMatrix); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTexture", _m_GetTexture); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetFloatArray", _m_GetFloatArray); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetColorArray", _m_GetColorArray); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetVectorArray", _m_GetVectorArray); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetMatrixArray", _m_GetMatrixArray); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTextureOffset", _m_SetTextureOffset); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTextureScale", _m_SetTextureScale); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTextureOffset", _m_GetTextureOffset); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTextureScale", _m_GetTextureScale); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasProperty", _m_HasProperty); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasFloat", _m_HasFloat); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasInt", _m_HasInt); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasInteger", _m_HasInteger); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasTexture", _m_HasTexture); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasMatrix", _m_HasMatrix); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasVector", _m_HasVector); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasColor", _m_HasColor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasBuffer", _m_HasBuffer); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasConstantBuffer", _m_HasConstantBuffer); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "EnableKeyword", _m_EnableKeyword); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DisableKeyword", _m_DisableKeyword); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsKeywordEnabled", _m_IsKeywordEnabled); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetKeyword", _m_SetKeyword); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetShaderPassEnabled", _m_SetShaderPassEnabled); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetShaderPassEnabled", _m_GetShaderPassEnabled); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPassName", _m_GetPassName); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindPass", _m_FindPass); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetOverrideTag", _m_SetOverrideTag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTag", _m_GetTag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Lerp", _m_Lerp); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPass", _m_SetPass); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CopyPropertiesFromMaterial", _m_CopyPropertiesFromMaterial); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CopyMatchingPropertiesFromMaterial", _m_CopyMatchingPropertiesFromMaterial); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ComputeCRC", _m_ComputeCRC); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTexturePropertyNames", _m_GetTexturePropertyNames); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTexturePropertyNameIDs", _m_GetTexturePropertyNameIDs); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOGradientColor", _m_DOGradientColor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOOffset", _m_DOOffset); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOTiling", _m_DOTiling); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOColor", _m_DOColor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOFade", _m_DOFade); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOFloat", _m_DOFloat); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOVector", _m_DOVector); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOBlendableColor", _m_DOBlendableColor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOComplete", _m_DOComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOKill", _m_DOKill); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOFlip", _m_DOFlip); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOGoto", _m_DOGoto); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOPause", _m_DOPause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOPlay", _m_DOPlay); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOPlayBackwards", _m_DOPlayBackwards); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOPlayForward", _m_DOPlayForward); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DORestart", _m_DORestart); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DORewind", _m_DORewind); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOSmoothRewind", _m_DOSmoothRewind); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOTogglePause", _m_DOTogglePause); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "shader", _g_get_shader); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "color", _g_get_color); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mainTexture", _g_get_mainTexture); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mainTextureOffset", _g_get_mainTextureOffset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mainTextureScale", _g_get_mainTextureScale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "renderQueue", _g_get_renderQueue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enabledKeywords", _g_get_enabledKeywords); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "globalIlluminationFlags", _g_get_globalIlluminationFlags); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "doubleSidedGI", _g_get_doubleSidedGI); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enableInstancing", _g_get_enableInstancing); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "passCount", _g_get_passCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "shaderKeywords", _g_get_shaderKeywords); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "shader", _s_set_shader); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "color", _s_set_color); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "mainTexture", _s_set_mainTexture); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "mainTextureOffset", _s_set_mainTextureOffset); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "mainTextureScale", _s_set_mainTextureScale); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "renderQueue", _s_set_renderQueue); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enabledKeywords", _s_set_enabledKeywords); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "globalIlluminationFlags", _s_set_globalIlluminationFlags); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "doubleSidedGI", _s_set_doubleSidedGI); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enableInstancing", _s_set_enableInstancing); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "shaderKeywords", _s_set_shaderKeywords); + + + 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) == 2 && translator.Assignable(L, 2)) + { + UnityEngine.Shader _shader = (UnityEngine.Shader)translator.GetObject(L, 2, typeof(UnityEngine.Shader)); + + var gen_ret = new UnityEngine.Material(_shader); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && translator.Assignable(L, 2)) + { + UnityEngine.Material _source = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + var gen_ret = new UnityEngine.Material(_source); + 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 UnityEngine.Material constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetInt(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + int _value = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetInt( _nameID, _value ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + int _value = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetInt( _name, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Material.SetInt!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetFloat(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + float _value = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetFloat( _nameID, _value ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + float _value = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetFloat( _name, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Material.SetFloat!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetInteger(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + int _value = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetInteger( _nameID, _value ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + int _value = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetInteger( _name, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Material.SetInteger!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Color _value;translator.Get(L, 3, out _value); + + gen_to_be_invoked.SetColor( _nameID, _value ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + UnityEngine.Color _value;translator.Get(L, 3, out _value); + + gen_to_be_invoked.SetColor( _name, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Material.SetColor!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetVector(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Vector4 _value;translator.Get(L, 3, out _value); + + gen_to_be_invoked.SetVector( _nameID, _value ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + UnityEngine.Vector4 _value;translator.Get(L, 3, out _value); + + gen_to_be_invoked.SetVector( _name, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Material.SetVector!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMatrix(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Matrix4x4 _value;translator.Get(L, 3, out _value); + + gen_to_be_invoked.SetMatrix( _nameID, _value ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + UnityEngine.Matrix4x4 _value;translator.Get(L, 3, out _value); + + gen_to_be_invoked.SetMatrix( _name, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Material.SetMatrix!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTexture(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Texture _value = (UnityEngine.Texture)translator.GetObject(L, 3, typeof(UnityEngine.Texture)); + + gen_to_be_invoked.SetTexture( _nameID, _value ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + UnityEngine.Texture _value = (UnityEngine.Texture)translator.GetObject(L, 3, typeof(UnityEngine.Texture)); + + gen_to_be_invoked.SetTexture( _name, _value ); + + + + return 0; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.RenderTexture _value = (UnityEngine.RenderTexture)translator.GetObject(L, 3, typeof(UnityEngine.RenderTexture)); + UnityEngine.Rendering.RenderTextureSubElement _element;translator.Get(L, 4, out _element); + + gen_to_be_invoked.SetTexture( _nameID, _value, _element ); + + + + return 0; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + string _name = LuaAPI.lua_tostring(L, 2); + UnityEngine.RenderTexture _value = (UnityEngine.RenderTexture)translator.GetObject(L, 3, typeof(UnityEngine.RenderTexture)); + UnityEngine.Rendering.RenderTextureSubElement _element;translator.Get(L, 4, out _element); + + gen_to_be_invoked.SetTexture( _name, _value, _element ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Material.SetTexture!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetBuffer(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.ComputeBuffer _value = (UnityEngine.ComputeBuffer)translator.GetObject(L, 3, typeof(UnityEngine.ComputeBuffer)); + + gen_to_be_invoked.SetBuffer( _nameID, _value ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.GraphicsBuffer _value = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 3, typeof(UnityEngine.GraphicsBuffer)); + + gen_to_be_invoked.SetBuffer( _nameID, _value ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + UnityEngine.ComputeBuffer _value = (UnityEngine.ComputeBuffer)translator.GetObject(L, 3, typeof(UnityEngine.ComputeBuffer)); + + gen_to_be_invoked.SetBuffer( _name, _value ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + UnityEngine.GraphicsBuffer _value = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 3, typeof(UnityEngine.GraphicsBuffer)); + + gen_to_be_invoked.SetBuffer( _name, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Material.SetBuffer!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetConstantBuffer(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.ComputeBuffer _value = (UnityEngine.ComputeBuffer)translator.GetObject(L, 3, typeof(UnityEngine.ComputeBuffer)); + int _offset = LuaAPI.xlua_tointeger(L, 4); + int _size = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.SetConstantBuffer( _nameID, _value, _offset, _size ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.GraphicsBuffer _value = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 3, typeof(UnityEngine.GraphicsBuffer)); + int _offset = LuaAPI.xlua_tointeger(L, 4); + int _size = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.SetConstantBuffer( _nameID, _value, _offset, _size ); + + + + return 0; + } + if(gen_param_count == 5&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + string _name = LuaAPI.lua_tostring(L, 2); + UnityEngine.ComputeBuffer _value = (UnityEngine.ComputeBuffer)translator.GetObject(L, 3, typeof(UnityEngine.ComputeBuffer)); + int _offset = LuaAPI.xlua_tointeger(L, 4); + int _size = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.SetConstantBuffer( _name, _value, _offset, _size ); + + + + return 0; + } + if(gen_param_count == 5&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + string _name = LuaAPI.lua_tostring(L, 2); + UnityEngine.GraphicsBuffer _value = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 3, typeof(UnityEngine.GraphicsBuffer)); + int _offset = LuaAPI.xlua_tointeger(L, 4); + int _size = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.SetConstantBuffer( _name, _value, _offset, _size ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Material.SetConstantBuffer!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetFloatArray(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.SetFloatArray( _nameID, _values ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + float[] _values = (float[])translator.GetObject(L, 3, typeof(float[])); + + gen_to_be_invoked.SetFloatArray( _nameID, _values ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.SetFloatArray( _name, _values ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + float[] _values = (float[])translator.GetObject(L, 3, typeof(float[])); + + gen_to_be_invoked.SetFloatArray( _name, _values ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Material.SetFloatArray!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetColorArray(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.SetColorArray( _nameID, _values ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Color[] _values = (UnityEngine.Color[])translator.GetObject(L, 3, typeof(UnityEngine.Color[])); + + gen_to_be_invoked.SetColorArray( _nameID, _values ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.SetColorArray( _name, _values ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + UnityEngine.Color[] _values = (UnityEngine.Color[])translator.GetObject(L, 3, typeof(UnityEngine.Color[])); + + gen_to_be_invoked.SetColorArray( _name, _values ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Material.SetColorArray!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetVectorArray(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.SetVectorArray( _nameID, _values ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Vector4[] _values = (UnityEngine.Vector4[])translator.GetObject(L, 3, typeof(UnityEngine.Vector4[])); + + gen_to_be_invoked.SetVectorArray( _nameID, _values ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.SetVectorArray( _name, _values ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + UnityEngine.Vector4[] _values = (UnityEngine.Vector4[])translator.GetObject(L, 3, typeof(UnityEngine.Vector4[])); + + gen_to_be_invoked.SetVectorArray( _name, _values ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Material.SetVectorArray!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMatrixArray(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.SetMatrixArray( _nameID, _values ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Matrix4x4[] _values = (UnityEngine.Matrix4x4[])translator.GetObject(L, 3, typeof(UnityEngine.Matrix4x4[])); + + gen_to_be_invoked.SetMatrixArray( _nameID, _values ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.SetMatrixArray( _name, _values ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + UnityEngine.Matrix4x4[] _values = (UnityEngine.Matrix4x4[])translator.GetObject(L, 3, typeof(UnityEngine.Matrix4x4[])); + + gen_to_be_invoked.SetMatrixArray( _name, _values ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Material.SetMatrixArray!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetInt(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetInt( _nameID ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetInt( _name ); + LuaAPI.xlua_pushinteger(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 UnityEngine.Material.GetInt!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetFloat(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetFloat( _nameID ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetFloat( _name ); + LuaAPI.lua_pushnumber(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 UnityEngine.Material.GetFloat!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetInteger(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetInteger( _nameID ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetInteger( _name ); + LuaAPI.xlua_pushinteger(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 UnityEngine.Material.GetInteger!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetColor( _nameID ); + translator.PushUnityEngineColor(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetColor( _name ); + translator.PushUnityEngineColor(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 UnityEngine.Material.GetColor!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetVector(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetVector( _nameID ); + translator.PushUnityEngineVector4(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetVector( _name ); + translator.PushUnityEngineVector4(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 UnityEngine.Material.GetVector!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetMatrix(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetMatrix( _nameID ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetMatrix( _name ); + 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 UnityEngine.Material.GetMatrix!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetTexture(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetTexture( _nameID ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetTexture( _name ); + 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 UnityEngine.Material.GetTexture!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetFloatArray(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetFloatArray( _nameID ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetFloatArray( _name ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetFloatArray( _nameID, _values ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetFloatArray( _name, _values ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Material.GetFloatArray!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetColorArray(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetColorArray( _nameID ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetColorArray( _name ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetColorArray( _nameID, _values ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetColorArray( _name, _values ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Material.GetColorArray!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetVectorArray(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetVectorArray( _nameID ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetVectorArray( _name ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetVectorArray( _nameID, _values ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetVectorArray( _name, _values ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Material.GetVectorArray!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetMatrixArray(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetMatrixArray( _nameID ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetMatrixArray( _name ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetMatrixArray( _nameID, _values ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable>(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetMatrixArray( _name, _values ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Material.GetMatrixArray!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTextureOffset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Vector2 _value;translator.Get(L, 3, out _value); + + gen_to_be_invoked.SetTextureOffset( _nameID, _value ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + UnityEngine.Vector2 _value;translator.Get(L, 3, out _value); + + gen_to_be_invoked.SetTextureOffset( _name, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Material.SetTextureOffset!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTextureScale(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Vector2 _value;translator.Get(L, 3, out _value); + + gen_to_be_invoked.SetTextureScale( _nameID, _value ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 2); + UnityEngine.Vector2 _value;translator.Get(L, 3, out _value); + + gen_to_be_invoked.SetTextureScale( _name, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Material.SetTextureScale!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetTextureOffset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetTextureOffset( _nameID ); + translator.PushUnityEngineVector2(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetTextureOffset( _name ); + translator.PushUnityEngineVector2(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 UnityEngine.Material.GetTextureOffset!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetTextureScale(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetTextureScale( _nameID ); + translator.PushUnityEngineVector2(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetTextureScale( _name ); + translator.PushUnityEngineVector2(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 UnityEngine.Material.GetTextureScale!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasProperty(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.HasProperty( _nameID ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.HasProperty( _name ); + LuaAPI.lua_pushboolean(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 UnityEngine.Material.HasProperty!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasFloat(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.HasFloat( _nameID ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.HasFloat( _name ); + LuaAPI.lua_pushboolean(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 UnityEngine.Material.HasFloat!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasInt(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.HasInt( _nameID ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.HasInt( _name ); + LuaAPI.lua_pushboolean(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 UnityEngine.Material.HasInt!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasInteger(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.HasInteger( _nameID ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.HasInteger( _name ); + LuaAPI.lua_pushboolean(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 UnityEngine.Material.HasInteger!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasTexture(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.HasTexture( _nameID ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.HasTexture( _name ); + LuaAPI.lua_pushboolean(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 UnityEngine.Material.HasTexture!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasMatrix(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.HasMatrix( _nameID ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.HasMatrix( _name ); + LuaAPI.lua_pushboolean(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 UnityEngine.Material.HasMatrix!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasVector(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.HasVector( _nameID ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.HasVector( _name ); + LuaAPI.lua_pushboolean(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 UnityEngine.Material.HasVector!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.HasColor( _nameID ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.HasColor( _name ); + LuaAPI.lua_pushboolean(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 UnityEngine.Material.HasColor!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasBuffer(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.HasBuffer( _nameID ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.HasBuffer( _name ); + LuaAPI.lua_pushboolean(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 UnityEngine.Material.HasBuffer!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasConstantBuffer(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.HasConstantBuffer( _nameID ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.HasConstantBuffer( _name ); + LuaAPI.lua_pushboolean(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 UnityEngine.Material.HasConstantBuffer!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_EnableKeyword(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _keyword = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.EnableKeyword( _keyword ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Rendering.LocalKeyword _keyword;translator.Get(L, 2, out _keyword); + + gen_to_be_invoked.EnableKeyword( _keyword ); + translator.Push(L, _keyword); + translator.Update(L, 2, _keyword); + + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Material.EnableKeyword!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DisableKeyword(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _keyword = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.DisableKeyword( _keyword ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Rendering.LocalKeyword _keyword;translator.Get(L, 2, out _keyword); + + gen_to_be_invoked.DisableKeyword( _keyword ); + translator.Push(L, _keyword); + translator.Update(L, 2, _keyword); + + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Material.DisableKeyword!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsKeywordEnabled(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _keyword = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.IsKeywordEnabled( _keyword ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Rendering.LocalKeyword _keyword;translator.Get(L, 2, out _keyword); + + var gen_ret = gen_to_be_invoked.IsKeywordEnabled( _keyword ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _keyword); + translator.Update(L, 2, _keyword); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Material.IsKeywordEnabled!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetKeyword(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Rendering.LocalKeyword _keyword;translator.Get(L, 2, out _keyword); + bool _value = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.SetKeyword( _keyword, _value ); + translator.Push(L, _keyword); + translator.Update(L, 2, _keyword); + + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetShaderPassEnabled(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + + { + string _passName = LuaAPI.lua_tostring(L, 2); + bool _enabled = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.SetShaderPassEnabled( _passName, _enabled ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetShaderPassEnabled(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + + { + string _passName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetShaderPassEnabled( _passName ); + 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_GetPassName(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + + { + int _pass = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetPassName( _pass ); + 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 _m_FindPass(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + + { + string _passName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.FindPass( _passName ); + 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_SetOverrideTag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + + { + string _tag = LuaAPI.lua_tostring(L, 2); + string _val = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.SetOverrideTag( _tag, _val ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetTag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + string _tag = LuaAPI.lua_tostring(L, 2); + bool _searchFallbacks = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.GetTag( _tag, _searchFallbacks ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)) + { + string _tag = LuaAPI.lua_tostring(L, 2); + bool _searchFallbacks = LuaAPI.lua_toboolean(L, 3); + string _defaultValue = LuaAPI.lua_tostring(L, 4); + + var gen_ret = gen_to_be_invoked.GetTag( _tag, _searchFallbacks, _defaultValue ); + LuaAPI.lua_pushstring(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 UnityEngine.Material.GetTag!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Lerp(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Material _start = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + UnityEngine.Material _end = (UnityEngine.Material)translator.GetObject(L, 3, typeof(UnityEngine.Material)); + float _t = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.Lerp( _start, _end, _t ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetPass(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + + { + int _pass = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.SetPass( _pass ); + 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_CopyPropertiesFromMaterial(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Material _mat = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + gen_to_be_invoked.CopyPropertiesFromMaterial( _mat ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CopyMatchingPropertiesFromMaterial(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Material _mat = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + gen_to_be_invoked.CopyMatchingPropertiesFromMaterial( _mat ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ComputeCRC(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.ComputeCRC( ); + 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_GetTexturePropertyNames(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.GetTexturePropertyNames( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.List _outNames = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetTexturePropertyNames( _outNames ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Material.GetTexturePropertyNames!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetTexturePropertyNameIDs(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.GetTexturePropertyNameIDs( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.List _outNames = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetTexturePropertyNameIDs( _outNames ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Material.GetTexturePropertyNameIDs!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOGradientColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Gradient _gradient = (UnityEngine.Gradient)translator.GetObject(L, 2, typeof(UnityEngine.Gradient)); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOGradientColor( _gradient, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Gradient _gradient = (UnityEngine.Gradient)translator.GetObject(L, 2, typeof(UnityEngine.Gradient)); + string _property = LuaAPI.lua_tostring(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.DOGradientColor( _gradient, _property, _duration ); + 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 UnityEngine.Material.DOGradientColor!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOOffset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector2 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOOffset( _endValue, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector2 _endValue;translator.Get(L, 2, out _endValue); + int _propertyID = LuaAPI.xlua_tointeger(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.DOOffset( _endValue, _propertyID, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector2 _endValue;translator.Get(L, 2, out _endValue); + string _property = LuaAPI.lua_tostring(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.DOOffset( _endValue, _property, _duration ); + 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 UnityEngine.Material.DOOffset!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOTiling(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector2 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOTiling( _endValue, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector2 _endValue;translator.Get(L, 2, out _endValue); + int _propertyID = LuaAPI.xlua_tointeger(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.DOTiling( _endValue, _propertyID, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector2 _endValue;translator.Get(L, 2, out _endValue); + string _property = LuaAPI.lua_tostring(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.DOTiling( _endValue, _property, _duration ); + 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 UnityEngine.Material.DOTiling!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Color _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOColor( _endValue, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Color _endValue;translator.Get(L, 2, out _endValue); + int _propertyID = LuaAPI.xlua_tointeger(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.DOColor( _endValue, _propertyID, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Color _endValue;translator.Get(L, 2, out _endValue); + string _property = LuaAPI.lua_tostring(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.DOColor( _endValue, _property, _duration ); + 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 UnityEngine.Material.DOColor!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOFade(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOFade( _endValue, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + int _propertyID = LuaAPI.xlua_tointeger(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.DOFade( _endValue, _propertyID, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + string _property = LuaAPI.lua_tostring(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.DOFade( _endValue, _property, _duration ); + 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 UnityEngine.Material.DOFade!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOFloat(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + int _propertyID = LuaAPI.xlua_tointeger(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.DOFloat( _endValue, _propertyID, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + string _property = LuaAPI.lua_tostring(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.DOFloat( _endValue, _property, _duration ); + 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 UnityEngine.Material.DOFloat!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOVector(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector4 _endValue;translator.Get(L, 2, out _endValue); + int _propertyID = LuaAPI.xlua_tointeger(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.DOVector( _endValue, _propertyID, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector4 _endValue;translator.Get(L, 2, out _endValue); + string _property = LuaAPI.lua_tostring(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.DOVector( _endValue, _property, _duration ); + 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 UnityEngine.Material.DOVector!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOBlendableColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Color _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOBlendableColor( _endValue, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Color _endValue;translator.Get(L, 2, out _endValue); + int _propertyID = LuaAPI.xlua_tointeger(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.DOBlendableColor( _endValue, _propertyID, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Color _endValue;translator.Get(L, 2, out _endValue); + string _property = LuaAPI.lua_tostring(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.DOBlendableColor( _endValue, _property, _duration ); + 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 UnityEngine.Material.DOBlendableColor!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _withCallbacks = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.DOComplete( _withCallbacks ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.DOComplete( ); + LuaAPI.xlua_pushinteger(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 UnityEngine.Material.DOComplete!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOKill(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _complete = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.DOKill( _complete ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.DOKill( ); + LuaAPI.xlua_pushinteger(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 UnityEngine.Material.DOKill!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOFlip(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.DOFlip( ); + 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_DOGoto(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + float _to = (float)LuaAPI.lua_tonumber(L, 2); + bool _andPlay = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.DOGoto( _to, _andPlay ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _to = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.DOGoto( _to ); + LuaAPI.xlua_pushinteger(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 UnityEngine.Material.DOGoto!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOPause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.DOPause( ); + 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_DOPlay(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.DOPlay( ); + 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_DOPlayBackwards(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.DOPlayBackwards( ); + 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_DOPlayForward(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.DOPlayForward( ); + 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_DORestart(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _includeDelay = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.DORestart( _includeDelay ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.DORestart( ); + LuaAPI.xlua_pushinteger(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 UnityEngine.Material.DORestart!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DORewind(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _includeDelay = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.DORewind( _includeDelay ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.DORewind( ); + LuaAPI.xlua_pushinteger(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 UnityEngine.Material.DORewind!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOSmoothRewind(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.DOSmoothRewind( ); + 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_DOTogglePause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.DOTogglePause( ); + 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 _g_get_shader(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.shader); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_color(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineColor(L, gen_to_be_invoked.color); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mainTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.mainTexture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mainTextureOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.mainTextureOffset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mainTextureScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.mainTextureScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_renderQueue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.renderQueue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enabledKeywords(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.enabledKeywords); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_globalIlluminationFlags(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.globalIlluminationFlags); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_doubleSidedGI(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.doubleSidedGI); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enableInstancing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.enableInstancing); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_passCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.passCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_shaderKeywords(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.shaderKeywords); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_shader(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.shader = (UnityEngine.Shader)translator.GetObject(L, 2, typeof(UnityEngine.Shader)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_color(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + UnityEngine.Color gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.color = 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_mainTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.mainTexture = (UnityEngine.Texture)translator.GetObject(L, 2, typeof(UnityEngine.Texture)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_mainTextureOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.mainTextureOffset = 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_mainTextureScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.mainTextureScale = 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_renderQueue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.renderQueue = 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_enabledKeywords(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.enabledKeywords = (UnityEngine.Rendering.LocalKeyword[])translator.GetObject(L, 2, typeof(UnityEngine.Rendering.LocalKeyword[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_globalIlluminationFlags(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + UnityEngine.MaterialGlobalIlluminationFlags gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.globalIlluminationFlags = 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_doubleSidedGI(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.doubleSidedGI = 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_enableInstancing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.enableInstancing = 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_shaderKeywords(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Material gen_to_be_invoked = (UnityEngine.Material)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.shaderKeywords = (string[])translator.GetObject(L, 2, typeof(string[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_MathfWrap.cs b/Assets/XLua/Gen/UnityEngine_MathfWrap.cs new file mode 100644 index 000000000..6224aacdf --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_MathfWrap.cs @@ -0,0 +1,1555 @@ +#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 UnityEngineMathfWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Mathf); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 54, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Sin", _m_Sin_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Cos", _m_Cos_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Tan", _m_Tan_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Asin", _m_Asin_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Acos", _m_Acos_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Atan", _m_Atan_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Atan2", _m_Atan2_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Sqrt", _m_Sqrt_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Abs", _m_Abs_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Min", _m_Min_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Max", _m_Max_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Pow", _m_Pow_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Exp", _m_Exp_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Log", _m_Log_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Log10", _m_Log10_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Ceil", _m_Ceil_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Floor", _m_Floor_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Round", _m_Round_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CeilToInt", _m_CeilToInt_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FloorToInt", _m_FloorToInt_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RoundToInt", _m_RoundToInt_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Sign", _m_Sign_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Clamp", _m_Clamp_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Clamp01", _m_Clamp01_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Lerp", _m_Lerp_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LerpUnclamped", _m_LerpUnclamped_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LerpAngle", _m_LerpAngle_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "MoveTowards", _m_MoveTowards_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "MoveTowardsAngle", _m_MoveTowardsAngle_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SmoothStep", _m_SmoothStep_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Gamma", _m_Gamma_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Approximately", _m_Approximately_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SmoothDamp", _m_SmoothDamp_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SmoothDampAngle", _m_SmoothDampAngle_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Repeat", _m_Repeat_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "PingPong", _m_PingPong_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "InverseLerp", _m_InverseLerp_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "DeltaAngle", _m_DeltaAngle_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ClosestPowerOfTwo", _m_ClosestPowerOfTwo_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IsPowerOfTwo", _m_IsPowerOfTwo_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "NextPowerOfTwo", _m_NextPowerOfTwo_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GammaToLinearSpace", _m_GammaToLinearSpace_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LinearToGammaSpace", _m_LinearToGammaSpace_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CorrelatedColorTemperatureToRGB", _m_CorrelatedColorTemperatureToRGB_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FloatToHalf", _m_FloatToHalf_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "HalfToFloat", _m_HalfToFloat_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "PerlinNoise", _m_PerlinNoise_xlua_st_); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PI", UnityEngine.Mathf.PI); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Infinity", UnityEngine.Mathf.Infinity); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NegativeInfinity", UnityEngine.Mathf.NegativeInfinity); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Deg2Rad", UnityEngine.Mathf.Deg2Rad); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Rad2Deg", UnityEngine.Mathf.Rad2Deg); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Epsilon", UnityEngine.Mathf.Epsilon); + + + + + 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) + { + translator.Push(L, default(UnityEngine.Mathf)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Mathf constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Sin_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _f = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = UnityEngine.Mathf.Sin( _f ); + LuaAPI.lua_pushnumber(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_Cos_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _f = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = UnityEngine.Mathf.Cos( _f ); + LuaAPI.lua_pushnumber(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_Tan_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _f = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = UnityEngine.Mathf.Tan( _f ); + LuaAPI.lua_pushnumber(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_Asin_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _f = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = UnityEngine.Mathf.Asin( _f ); + LuaAPI.lua_pushnumber(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_Acos_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _f = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = UnityEngine.Mathf.Acos( _f ); + LuaAPI.lua_pushnumber(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_Atan_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _f = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = UnityEngine.Mathf.Atan( _f ); + LuaAPI.lua_pushnumber(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_Atan2_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _y = (float)LuaAPI.lua_tonumber(L, 1); + float _x = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = UnityEngine.Mathf.Atan2( _y, _x ); + LuaAPI.lua_pushnumber(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_Sqrt_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _f = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = UnityEngine.Mathf.Sqrt( _f ); + LuaAPI.lua_pushnumber(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_Abs_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + float _f = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = UnityEngine.Mathf.Abs( _f ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _value = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = UnityEngine.Mathf.Abs( _value ); + LuaAPI.xlua_pushinteger(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 UnityEngine.Mathf.Abs!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Min_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _a = (float)LuaAPI.lua_tonumber(L, 1); + float _b = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = UnityEngine.Mathf.Min( _a, _b ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _a = LuaAPI.xlua_tointeger(L, 1); + int _b = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = UnityEngine.Mathf.Min( _a, _b ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count >= 0&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 1) || LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1))) + { + float[] _values = translator.GetParams(L, 1); + + var gen_ret = UnityEngine.Mathf.Min( _values ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count >= 0&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 1) || LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1))) + { + int[] _values = translator.GetParams(L, 1); + + var gen_ret = UnityEngine.Mathf.Min( _values ); + LuaAPI.xlua_pushinteger(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 UnityEngine.Mathf.Min!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Max_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _a = (float)LuaAPI.lua_tonumber(L, 1); + float _b = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = UnityEngine.Mathf.Max( _a, _b ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _a = LuaAPI.xlua_tointeger(L, 1); + int _b = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = UnityEngine.Mathf.Max( _a, _b ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count >= 0&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 1) || LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1))) + { + float[] _values = translator.GetParams(L, 1); + + var gen_ret = UnityEngine.Mathf.Max( _values ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count >= 0&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 1) || LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1))) + { + int[] _values = translator.GetParams(L, 1); + + var gen_ret = UnityEngine.Mathf.Max( _values ); + LuaAPI.xlua_pushinteger(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 UnityEngine.Mathf.Max!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Pow_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _f = (float)LuaAPI.lua_tonumber(L, 1); + float _p = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = UnityEngine.Mathf.Pow( _f, _p ); + LuaAPI.lua_pushnumber(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_Exp_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _power = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = UnityEngine.Mathf.Exp( _power ); + LuaAPI.lua_pushnumber(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_Log_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + float _f = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = UnityEngine.Mathf.Log( _f ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _f = (float)LuaAPI.lua_tonumber(L, 1); + float _p = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = UnityEngine.Mathf.Log( _f, _p ); + LuaAPI.lua_pushnumber(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 UnityEngine.Mathf.Log!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Log10_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _f = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = UnityEngine.Mathf.Log10( _f ); + LuaAPI.lua_pushnumber(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_Ceil_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _f = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = UnityEngine.Mathf.Ceil( _f ); + LuaAPI.lua_pushnumber(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_Floor_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _f = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = UnityEngine.Mathf.Floor( _f ); + LuaAPI.lua_pushnumber(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_Round_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _f = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = UnityEngine.Mathf.Round( _f ); + LuaAPI.lua_pushnumber(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_CeilToInt_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _f = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = UnityEngine.Mathf.CeilToInt( _f ); + 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_FloorToInt_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _f = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = UnityEngine.Mathf.FloorToInt( _f ); + 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_RoundToInt_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _f = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = UnityEngine.Mathf.RoundToInt( _f ); + 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_Sign_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _f = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = UnityEngine.Mathf.Sign( _f ); + LuaAPI.lua_pushnumber(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_Clamp_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _value = (float)LuaAPI.lua_tonumber(L, 1); + float _min = (float)LuaAPI.lua_tonumber(L, 2); + float _max = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Mathf.Clamp( _value, _min, _max ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _value = LuaAPI.xlua_tointeger(L, 1); + int _min = LuaAPI.xlua_tointeger(L, 2); + int _max = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = UnityEngine.Mathf.Clamp( _value, _min, _max ); + LuaAPI.xlua_pushinteger(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 UnityEngine.Mathf.Clamp!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Clamp01_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _value = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = UnityEngine.Mathf.Clamp01( _value ); + LuaAPI.lua_pushnumber(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_Lerp_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _a = (float)LuaAPI.lua_tonumber(L, 1); + float _b = (float)LuaAPI.lua_tonumber(L, 2); + float _t = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Mathf.Lerp( _a, _b, _t ); + LuaAPI.lua_pushnumber(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_LerpUnclamped_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _a = (float)LuaAPI.lua_tonumber(L, 1); + float _b = (float)LuaAPI.lua_tonumber(L, 2); + float _t = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Mathf.LerpUnclamped( _a, _b, _t ); + LuaAPI.lua_pushnumber(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_LerpAngle_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _a = (float)LuaAPI.lua_tonumber(L, 1); + float _b = (float)LuaAPI.lua_tonumber(L, 2); + float _t = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Mathf.LerpAngle( _a, _b, _t ); + LuaAPI.lua_pushnumber(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_MoveTowards_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _current = (float)LuaAPI.lua_tonumber(L, 1); + float _target = (float)LuaAPI.lua_tonumber(L, 2); + float _maxDelta = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Mathf.MoveTowards( _current, _target, _maxDelta ); + LuaAPI.lua_pushnumber(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_MoveTowardsAngle_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _current = (float)LuaAPI.lua_tonumber(L, 1); + float _target = (float)LuaAPI.lua_tonumber(L, 2); + float _maxDelta = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Mathf.MoveTowardsAngle( _current, _target, _maxDelta ); + LuaAPI.lua_pushnumber(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_SmoothStep_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _from = (float)LuaAPI.lua_tonumber(L, 1); + float _to = (float)LuaAPI.lua_tonumber(L, 2); + float _t = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Mathf.SmoothStep( _from, _to, _t ); + LuaAPI.lua_pushnumber(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_Gamma_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _value = (float)LuaAPI.lua_tonumber(L, 1); + float _absmax = (float)LuaAPI.lua_tonumber(L, 2); + float _gamma = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Mathf.Gamma( _value, _absmax, _gamma ); + LuaAPI.lua_pushnumber(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_Approximately_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _a = (float)LuaAPI.lua_tonumber(L, 1); + float _b = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = UnityEngine.Mathf.Approximately( _a, _b ); + 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_SmoothDamp_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _current = (float)LuaAPI.lua_tonumber(L, 1); + float _target = (float)LuaAPI.lua_tonumber(L, 2); + float _currentVelocity = (float)LuaAPI.lua_tonumber(L, 3); + float _smoothTime = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = UnityEngine.Mathf.SmoothDamp( _current, _target, ref _currentVelocity, _smoothTime ); + LuaAPI.lua_pushnumber(L, gen_ret); + LuaAPI.lua_pushnumber(L, _currentVelocity); + + + + + return 2; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + float _current = (float)LuaAPI.lua_tonumber(L, 1); + float _target = (float)LuaAPI.lua_tonumber(L, 2); + float _currentVelocity = (float)LuaAPI.lua_tonumber(L, 3); + float _smoothTime = (float)LuaAPI.lua_tonumber(L, 4); + float _maxSpeed = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = UnityEngine.Mathf.SmoothDamp( _current, _target, ref _currentVelocity, _smoothTime, _maxSpeed ); + LuaAPI.lua_pushnumber(L, gen_ret); + LuaAPI.lua_pushnumber(L, _currentVelocity); + + + + + return 2; + } + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + float _current = (float)LuaAPI.lua_tonumber(L, 1); + float _target = (float)LuaAPI.lua_tonumber(L, 2); + float _currentVelocity = (float)LuaAPI.lua_tonumber(L, 3); + float _smoothTime = (float)LuaAPI.lua_tonumber(L, 4); + float _maxSpeed = (float)LuaAPI.lua_tonumber(L, 5); + float _deltaTime = (float)LuaAPI.lua_tonumber(L, 6); + + var gen_ret = UnityEngine.Mathf.SmoothDamp( _current, _target, ref _currentVelocity, _smoothTime, _maxSpeed, _deltaTime ); + LuaAPI.lua_pushnumber(L, gen_ret); + LuaAPI.lua_pushnumber(L, _currentVelocity); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Mathf.SmoothDamp!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SmoothDampAngle_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _current = (float)LuaAPI.lua_tonumber(L, 1); + float _target = (float)LuaAPI.lua_tonumber(L, 2); + float _currentVelocity = (float)LuaAPI.lua_tonumber(L, 3); + float _smoothTime = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = UnityEngine.Mathf.SmoothDampAngle( _current, _target, ref _currentVelocity, _smoothTime ); + LuaAPI.lua_pushnumber(L, gen_ret); + LuaAPI.lua_pushnumber(L, _currentVelocity); + + + + + return 2; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + float _current = (float)LuaAPI.lua_tonumber(L, 1); + float _target = (float)LuaAPI.lua_tonumber(L, 2); + float _currentVelocity = (float)LuaAPI.lua_tonumber(L, 3); + float _smoothTime = (float)LuaAPI.lua_tonumber(L, 4); + float _maxSpeed = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = UnityEngine.Mathf.SmoothDampAngle( _current, _target, ref _currentVelocity, _smoothTime, _maxSpeed ); + LuaAPI.lua_pushnumber(L, gen_ret); + LuaAPI.lua_pushnumber(L, _currentVelocity); + + + + + return 2; + } + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + float _current = (float)LuaAPI.lua_tonumber(L, 1); + float _target = (float)LuaAPI.lua_tonumber(L, 2); + float _currentVelocity = (float)LuaAPI.lua_tonumber(L, 3); + float _smoothTime = (float)LuaAPI.lua_tonumber(L, 4); + float _maxSpeed = (float)LuaAPI.lua_tonumber(L, 5); + float _deltaTime = (float)LuaAPI.lua_tonumber(L, 6); + + var gen_ret = UnityEngine.Mathf.SmoothDampAngle( _current, _target, ref _currentVelocity, _smoothTime, _maxSpeed, _deltaTime ); + LuaAPI.lua_pushnumber(L, gen_ret); + LuaAPI.lua_pushnumber(L, _currentVelocity); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Mathf.SmoothDampAngle!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Repeat_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _t = (float)LuaAPI.lua_tonumber(L, 1); + float _length = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = UnityEngine.Mathf.Repeat( _t, _length ); + LuaAPI.lua_pushnumber(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_PingPong_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _t = (float)LuaAPI.lua_tonumber(L, 1); + float _length = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = UnityEngine.Mathf.PingPong( _t, _length ); + LuaAPI.lua_pushnumber(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_InverseLerp_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _a = (float)LuaAPI.lua_tonumber(L, 1); + float _b = (float)LuaAPI.lua_tonumber(L, 2); + float _value = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Mathf.InverseLerp( _a, _b, _value ); + LuaAPI.lua_pushnumber(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_DeltaAngle_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _current = (float)LuaAPI.lua_tonumber(L, 1); + float _target = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = UnityEngine.Mathf.DeltaAngle( _current, _target ); + LuaAPI.lua_pushnumber(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_ClosestPowerOfTwo_xlua_st_(RealStatePtr L) + { + try { + + + + + { + int _value = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = UnityEngine.Mathf.ClosestPowerOfTwo( _value ); + 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_IsPowerOfTwo_xlua_st_(RealStatePtr L) + { + try { + + + + + { + int _value = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = UnityEngine.Mathf.IsPowerOfTwo( _value ); + 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_NextPowerOfTwo_xlua_st_(RealStatePtr L) + { + try { + + + + + { + int _value = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = UnityEngine.Mathf.NextPowerOfTwo( _value ); + 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_GammaToLinearSpace_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _value = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = UnityEngine.Mathf.GammaToLinearSpace( _value ); + LuaAPI.lua_pushnumber(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_LinearToGammaSpace_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _value = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = UnityEngine.Mathf.LinearToGammaSpace( _value ); + LuaAPI.lua_pushnumber(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_CorrelatedColorTemperatureToRGB_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + float _kelvin = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = UnityEngine.Mathf.CorrelatedColorTemperatureToRGB( _kelvin ); + translator.PushUnityEngineColor(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_FloatToHalf_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _val = (float)LuaAPI.lua_tonumber(L, 1); + + var gen_ret = UnityEngine.Mathf.FloatToHalf( _val ); + 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_HalfToFloat_xlua_st_(RealStatePtr L) + { + try { + + + + + { + ushort _val = (ushort)LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = UnityEngine.Mathf.HalfToFloat( _val ); + LuaAPI.lua_pushnumber(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_PerlinNoise_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _x = (float)LuaAPI.lua_tonumber(L, 1); + float _y = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = UnityEngine.Mathf.PerlinNoise( _x, _y ); + LuaAPI.lua_pushnumber(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/UnityEngine_Matrix4x4Wrap.cs b/Assets/XLua/Gen/UnityEngine_Matrix4x4Wrap.cs new file mode 100644 index 000000000..6b4faed58 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_Matrix4x4Wrap.cs @@ -0,0 +1,1734 @@ +#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 UnityEngineMatrix4x4Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Matrix4x4); + Utils.BeginObjectRegister(type, L, translator, 2, 14, 23, 16); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__mul", __MulMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__eq", __EqMeta); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ValidTRS", _m_ValidTRS); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTRS", _m_SetTRS); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashCode", _m_GetHashCode); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Equals", _m_Equals); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetColumn", _m_GetColumn); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetRow", _m_GetRow); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPosition", _m_GetPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetColumn", _m_SetColumn); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRow", _m_SetRow); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "MultiplyPoint", _m_MultiplyPoint); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "MultiplyPoint3x4", _m_MultiplyPoint3x4); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "MultiplyVector", _m_MultiplyVector); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TransformPlane", _m_TransformPlane); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rotation", _g_get_rotation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lossyScale", _g_get_lossyScale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isIdentity", _g_get_isIdentity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "determinant", _g_get_determinant); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "decomposeProjection", _g_get_decomposeProjection); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "inverse", _g_get_inverse); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "transpose", _g_get_transpose); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "m00", _g_get_m00); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "m10", _g_get_m10); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "m20", _g_get_m20); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "m30", _g_get_m30); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "m01", _g_get_m01); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "m11", _g_get_m11); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "m21", _g_get_m21); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "m31", _g_get_m31); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "m02", _g_get_m02); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "m12", _g_get_m12); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "m22", _g_get_m22); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "m32", _g_get_m32); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "m03", _g_get_m03); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "m13", _g_get_m13); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "m23", _g_get_m23); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "m33", _g_get_m33); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "m00", _s_set_m00); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "m10", _s_set_m10); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "m20", _s_set_m20); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "m30", _s_set_m30); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "m01", _s_set_m01); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "m11", _s_set_m11); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "m21", _s_set_m21); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "m31", _s_set_m31); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "m02", _s_set_m02); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "m12", _s_set_m12); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "m22", _s_set_m22); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "m32", _s_set_m32); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "m03", _s_set_m03); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "m13", _s_set_m13); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "m23", _s_set_m23); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "m33", _s_set_m33); + + + Utils.EndObjectRegister(type, L, translator, __CSIndexer, __NewIndexer, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 13, 2, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Determinant", _m_Determinant_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "TRS", _m_TRS_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Inverse3DAffine", _m_Inverse3DAffine_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Inverse", _m_Inverse_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Transpose", _m_Transpose_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Ortho", _m_Ortho_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Perspective", _m_Perspective_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LookAt", _m_LookAt_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Frustum", _m_Frustum_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Scale", _m_Scale_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Translate", _m_Translate_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Rotate", _m_Rotate_xlua_st_); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "zero", _g_get_zero); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "identity", _g_get_identity); + + + + 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) == 5 && translator.Assignable(L, 2) && translator.Assignable(L, 3) && translator.Assignable(L, 4) && translator.Assignable(L, 5)) + { + UnityEngine.Vector4 _column0;translator.Get(L, 2, out _column0); + UnityEngine.Vector4 _column1;translator.Get(L, 3, out _column1); + UnityEngine.Vector4 _column2;translator.Get(L, 4, out _column2); + UnityEngine.Vector4 _column3;translator.Get(L, 5, out _column3); + + var gen_ret = new UnityEngine.Matrix4x4(_column0, _column1, _column2, _column3); + translator.Push(L, gen_ret); + + return 1; + } + + if (LuaAPI.lua_gettop(L) == 1) + { + translator.Push(L, default(UnityEngine.Matrix4x4)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Matrix4x4 constructor!"); + + } + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __CSIndexer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + if (translator.Assignable(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + int index = LuaAPI.xlua_tointeger(L, 2); + LuaAPI.lua_pushboolean(L, true); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked[index]); + return 2; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __NewIndexer(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + try { + + if (translator.Assignable(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + int key = LuaAPI.xlua_tointeger(L, 2); + gen_to_be_invoked[key] = (float)LuaAPI.lua_tonumber(L, 3); + LuaAPI.lua_pushboolean(L, true); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __MulMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + UnityEngine.Matrix4x4 leftside;translator.Get(L, 1, out leftside); + UnityEngine.Matrix4x4 rightside;translator.Get(L, 2, out rightside); + + translator.Push(L, leftside * rightside); + + return 1; + } + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + UnityEngine.Matrix4x4 leftside;translator.Get(L, 1, out leftside); + UnityEngine.Vector4 rightside;translator.Get(L, 2, out rightside); + + translator.PushUnityEngineVector4(L, leftside * rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of * operator, need UnityEngine.Matrix4x4!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __EqMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + UnityEngine.Matrix4x4 leftside;translator.Get(L, 1, out leftside); + UnityEngine.Matrix4x4 rightside;translator.Get(L, 2, out rightside); + + LuaAPI.lua_pushboolean(L, leftside == rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of == operator, need UnityEngine.Matrix4x4!"); + + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ValidTRS(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.ValidTRS( ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Determinant_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Matrix4x4 _m;translator.Get(L, 1, out _m); + + var gen_ret = UnityEngine.Matrix4x4.Determinant( _m ); + LuaAPI.lua_pushnumber(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_TRS_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector3 _pos;translator.Get(L, 1, out _pos); + UnityEngine.Quaternion _q;translator.Get(L, 2, out _q); + UnityEngine.Vector3 _s;translator.Get(L, 3, out _s); + + var gen_ret = UnityEngine.Matrix4x4.TRS( _pos, _q, _s ); + 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_SetTRS(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.Vector3 _pos;translator.Get(L, 2, out _pos); + UnityEngine.Quaternion _q;translator.Get(L, 3, out _q); + UnityEngine.Vector3 _s;translator.Get(L, 4, out _s); + + gen_to_be_invoked.SetTRS( _pos, _q, _s ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Inverse3DAffine_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Matrix4x4 _input;translator.Get(L, 1, out _input); + UnityEngine.Matrix4x4 _result;translator.Get(L, 2, out _result); + + var gen_ret = UnityEngine.Matrix4x4.Inverse3DAffine( _input, ref _result ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _result); + translator.Update(L, 2, _result); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Inverse_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Matrix4x4 _m;translator.Get(L, 1, out _m); + + var gen_ret = UnityEngine.Matrix4x4.Inverse( _m ); + 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_Transpose_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Matrix4x4 _m;translator.Get(L, 1, out _m); + + var gen_ret = UnityEngine.Matrix4x4.Transpose( _m ); + 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_Ortho_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + float _left = (float)LuaAPI.lua_tonumber(L, 1); + float _right = (float)LuaAPI.lua_tonumber(L, 2); + float _bottom = (float)LuaAPI.lua_tonumber(L, 3); + float _top = (float)LuaAPI.lua_tonumber(L, 4); + float _zNear = (float)LuaAPI.lua_tonumber(L, 5); + float _zFar = (float)LuaAPI.lua_tonumber(L, 6); + + var gen_ret = UnityEngine.Matrix4x4.Ortho( _left, _right, _bottom, _top, _zNear, _zFar ); + 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_Perspective_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + float _fov = (float)LuaAPI.lua_tonumber(L, 1); + float _aspect = (float)LuaAPI.lua_tonumber(L, 2); + float _zNear = (float)LuaAPI.lua_tonumber(L, 3); + float _zFar = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = UnityEngine.Matrix4x4.Perspective( _fov, _aspect, _zNear, _zFar ); + 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_LookAt_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector3 _from;translator.Get(L, 1, out _from); + UnityEngine.Vector3 _to;translator.Get(L, 2, out _to); + UnityEngine.Vector3 _up;translator.Get(L, 3, out _up); + + var gen_ret = UnityEngine.Matrix4x4.LookAt( _from, _to, _up ); + 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_Frustum_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + float _left = (float)LuaAPI.lua_tonumber(L, 1); + float _right = (float)LuaAPI.lua_tonumber(L, 2); + float _bottom = (float)LuaAPI.lua_tonumber(L, 3); + float _top = (float)LuaAPI.lua_tonumber(L, 4); + float _zNear = (float)LuaAPI.lua_tonumber(L, 5); + float _zFar = (float)LuaAPI.lua_tonumber(L, 6); + + var gen_ret = UnityEngine.Matrix4x4.Frustum( _left, _right, _bottom, _top, _zNear, _zFar ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + UnityEngine.FrustumPlanes _fp;translator.Get(L, 1, out _fp); + + var gen_ret = UnityEngine.Matrix4x4.Frustum( _fp ); + 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 UnityEngine.Matrix4x4.Frustum!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetHashCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.GetHashCode( ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Equals(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _other = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.Equals( _other ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Matrix4x4 _other;translator.Get(L, 2, out _other); + + var gen_ret = gen_to_be_invoked.Equals( _other ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Matrix4x4.Equals!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetColumn(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetColumn( _index ); + translator.PushUnityEngineVector4(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetRow(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetRow( _index ); + translator.PushUnityEngineVector4(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.GetPosition( ); + translator.PushUnityEngineVector3(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetColumn(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Vector4 _column;translator.Get(L, 3, out _column); + + gen_to_be_invoked.SetColumn( _index, _column ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRow(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Vector4 _row;translator.Get(L, 3, out _row); + + gen_to_be_invoked.SetRow( _index, _row ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_MultiplyPoint(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.Vector3 _point;translator.Get(L, 2, out _point); + + var gen_ret = gen_to_be_invoked.MultiplyPoint( _point ); + translator.PushUnityEngineVector3(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_MultiplyPoint3x4(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.Vector3 _point;translator.Get(L, 2, out _point); + + var gen_ret = gen_to_be_invoked.MultiplyPoint3x4( _point ); + translator.PushUnityEngineVector3(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_MultiplyVector(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.Vector3 _vector;translator.Get(L, 2, out _vector); + + var gen_ret = gen_to_be_invoked.MultiplyVector( _vector ); + translator.PushUnityEngineVector3(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TransformPlane(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.Plane _plane;translator.Get(L, 2, out _plane); + + var gen_ret = gen_to_be_invoked.TransformPlane( _plane ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Scale_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector3 _vector;translator.Get(L, 1, out _vector); + + var gen_ret = UnityEngine.Matrix4x4.Scale( _vector ); + 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_Translate_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector3 _vector;translator.Get(L, 1, out _vector); + + var gen_ret = UnityEngine.Matrix4x4.Translate( _vector ); + 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_Rotate_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Quaternion _q;translator.Get(L, 1, out _q); + + var gen_ret = UnityEngine.Matrix4x4.Rotate( _q ); + 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_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.ToString( ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _format = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.ToString( _format ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _format = LuaAPI.lua_tostring(L, 2); + System.IFormatProvider _formatProvider = (System.IFormatProvider)translator.GetObject(L, 3, typeof(System.IFormatProvider)); + + var gen_ret = gen_to_be_invoked.ToString( _format, _formatProvider ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Matrix4x4.ToString!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineQuaternion(L, gen_to_be_invoked.rotation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lossyScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.lossyScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isIdentity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isIdentity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_determinant(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.determinant); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_decomposeProjection(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.decomposeProjection); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_inverse(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.inverse); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_transpose(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.transpose); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_zero(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Matrix4x4.zero); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_identity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Matrix4x4.identity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_m00(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.m00); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_m10(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.m10); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_m20(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.m20); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_m30(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.m30); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_m01(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.m01); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_m11(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.m11); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_m21(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.m21); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_m31(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.m31); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_m02(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.m02); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_m12(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.m12); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_m22(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.m22); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_m32(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.m32); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_m03(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.m03); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_m13(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.m13); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_m23(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.m23); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_m33(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.m33); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_m00(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.m00 = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_m10(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.m10 = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_m20(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.m20 = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_m30(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.m30 = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_m01(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.m01 = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_m11(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.m11 = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_m21(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.m21 = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_m31(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.m31 = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_m02(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.m02 = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_m12(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.m12 = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_m22(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.m22 = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_m32(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.m32 = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_m03(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.m03 = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_m13(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.m13 = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_m23(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.m23 = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_m33(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Matrix4x4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.m33 = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_MeshColliderWrap.cs b/Assets/XLua/Gen/UnityEngine_MeshColliderWrap.cs new file mode 100644 index 000000000..16f7cd1cd --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_MeshColliderWrap.cs @@ -0,0 +1,178 @@ +#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 UnityEngineMeshColliderWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.MeshCollider); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 3, 3); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sharedMesh", _g_get_sharedMesh); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "convex", _g_get_convex); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "cookingOptions", _g_get_cookingOptions); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sharedMesh", _s_set_sharedMesh); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "convex", _s_set_convex); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "cookingOptions", _s_set_cookingOptions); + + + 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 UnityEngine.MeshCollider(); + 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 UnityEngine.MeshCollider constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sharedMesh(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.MeshCollider gen_to_be_invoked = (UnityEngine.MeshCollider)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.sharedMesh); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_convex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.MeshCollider gen_to_be_invoked = (UnityEngine.MeshCollider)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.convex); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cookingOptions(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.MeshCollider gen_to_be_invoked = (UnityEngine.MeshCollider)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.cookingOptions); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_sharedMesh(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.MeshCollider gen_to_be_invoked = (UnityEngine.MeshCollider)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.sharedMesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_convex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.MeshCollider gen_to_be_invoked = (UnityEngine.MeshCollider)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.convex = 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_cookingOptions(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.MeshCollider gen_to_be_invoked = (UnityEngine.MeshCollider)translator.FastGetCSObj(L, 1); + UnityEngine.MeshColliderCookingOptions gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.cookingOptions = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_MeshFilterWrap.cs b/Assets/XLua/Gen/UnityEngine_MeshFilterWrap.cs new file mode 100644 index 000000000..a5a20ec66 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_MeshFilterWrap.cs @@ -0,0 +1,146 @@ +#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 UnityEngineMeshFilterWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.MeshFilter); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 2); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sharedMesh", _g_get_sharedMesh); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mesh", _g_get_mesh); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sharedMesh", _s_set_sharedMesh); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "mesh", _s_set_mesh); + + + 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 UnityEngine.MeshFilter(); + 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 UnityEngine.MeshFilter constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sharedMesh(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.MeshFilter gen_to_be_invoked = (UnityEngine.MeshFilter)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.sharedMesh); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mesh(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.MeshFilter gen_to_be_invoked = (UnityEngine.MeshFilter)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.mesh); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_sharedMesh(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.MeshFilter gen_to_be_invoked = (UnityEngine.MeshFilter)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.sharedMesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_mesh(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.MeshFilter gen_to_be_invoked = (UnityEngine.MeshFilter)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_MeshRendererWrap.cs b/Assets/XLua/Gen/UnityEngine_MeshRendererWrap.cs new file mode 100644 index 000000000..b33e34bb6 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_MeshRendererWrap.cs @@ -0,0 +1,161 @@ +#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 UnityEngineMeshRendererWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.MeshRenderer); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 3, 2); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "additionalVertexStreams", _g_get_additionalVertexStreams); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enlightenVertexStream", _g_get_enlightenVertexStream); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "subMeshStartIndex", _g_get_subMeshStartIndex); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "additionalVertexStreams", _s_set_additionalVertexStreams); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enlightenVertexStream", _s_set_enlightenVertexStream); + + + 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 UnityEngine.MeshRenderer(); + 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 UnityEngine.MeshRenderer constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_additionalVertexStreams(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.MeshRenderer gen_to_be_invoked = (UnityEngine.MeshRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.additionalVertexStreams); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enlightenVertexStream(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.MeshRenderer gen_to_be_invoked = (UnityEngine.MeshRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.enlightenVertexStream); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_subMeshStartIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.MeshRenderer gen_to_be_invoked = (UnityEngine.MeshRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.subMeshStartIndex); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_additionalVertexStreams(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.MeshRenderer gen_to_be_invoked = (UnityEngine.MeshRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.additionalVertexStreams = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_enlightenVertexStream(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.MeshRenderer gen_to_be_invoked = (UnityEngine.MeshRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.enlightenVertexStream = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_MeshWrap.cs b/Assets/XLua/Gen/UnityEngine_MeshWrap.cs new file mode 100644 index 000000000..3fbc88a9d --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_MeshWrap.cs @@ -0,0 +1,4395 @@ +#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 UnityEngineMeshWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Mesh); + Utils.BeginObjectRegister(type, L, translator, 0, 61, 26, 21); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetVertices", _m_GetVertices); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetVertices", _m_SetVertices); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNormals", _m_GetNormals); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetNormals", _m_SetNormals); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTangents", _m_GetTangents); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTangents", _m_SetTangents); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetColors", _m_GetColors); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetColors", _m_SetColors); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetUVs", _m_SetUVs); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetUVs", _m_GetUVs); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetVertexAttributes", _m_GetVertexAttributes); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetVertexBufferParams", _m_SetVertexBufferParams); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetVertexBuffer", _m_GetVertexBuffer); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetIndexBuffer", _m_GetIndexBuffer); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTriangles", _m_GetTriangles); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetIndices", _m_GetIndices); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetIndexStart", _m_GetIndexStart); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetIndexCount", _m_GetIndexCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetBaseVertex", _m_GetBaseVertex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTriangles", _m_SetTriangles); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetIndices", _m_SetIndices); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSubMeshes", _m_SetSubMeshes); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetBindposes", _m_GetBindposes); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetBoneWeights", _m_GetBoneWeights); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RecalculateBounds", _m_RecalculateBounds); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RecalculateNormals", _m_RecalculateNormals); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RecalculateTangents", _m_RecalculateTangents); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RecalculateUVDistributionMetric", _m_RecalculateUVDistributionMetric); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RecalculateUVDistributionMetrics", _m_RecalculateUVDistributionMetrics); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "MarkDynamic", _m_MarkDynamic); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UploadMeshData", _m_UploadMeshData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Optimize", _m_Optimize); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OptimizeIndexBuffers", _m_OptimizeIndexBuffers); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OptimizeReorderVertexBuffer", _m_OptimizeReorderVertexBuffer); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTopology", _m_GetTopology); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CombineMeshes", _m_CombineMeshes); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetIndexBufferParams", _m_SetIndexBufferParams); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetVertexAttribute", _m_GetVertexAttribute); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasVertexAttribute", _m_HasVertexAttribute); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetVertexAttributeDimension", _m_GetVertexAttributeDimension); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetVertexAttributeFormat", _m_GetVertexAttributeFormat); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetVertexAttributeStream", _m_GetVertexAttributeStream); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetVertexAttributeOffset", _m_GetVertexAttributeOffset); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetVertexBufferStride", _m_GetVertexBufferStride); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNativeVertexBufferPtr", _m_GetNativeVertexBufferPtr); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNativeIndexBufferPtr", _m_GetNativeIndexBufferPtr); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearBlendShapes", _m_ClearBlendShapes); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetBlendShapeName", _m_GetBlendShapeName); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetBlendShapeIndex", _m_GetBlendShapeIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetBlendShapeFrameCount", _m_GetBlendShapeFrameCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetBlendShapeFrameWeight", _m_GetBlendShapeFrameWeight); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetBlendShapeFrameVertices", _m_GetBlendShapeFrameVertices); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddBlendShapeFrame", _m_AddBlendShapeFrame); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetBoneWeights", _m_SetBoneWeights); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAllBoneWeights", _m_GetAllBoneWeights); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetBonesPerVertex", _m_GetBonesPerVertex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSubMesh", _m_SetSubMesh); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSubMesh", _m_GetSubMesh); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "MarkModified", _m_MarkModified); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetUVDistributionMetric", _m_GetUVDistributionMetric); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "vertices", _g_get_vertices); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "normals", _g_get_normals); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "tangents", _g_get_tangents); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "uv", _g_get_uv); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "uv2", _g_get_uv2); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "uv3", _g_get_uv3); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "uv4", _g_get_uv4); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "uv5", _g_get_uv5); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "uv6", _g_get_uv6); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "uv7", _g_get_uv7); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "uv8", _g_get_uv8); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "colors", _g_get_colors); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "colors32", _g_get_colors32); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "vertexAttributeCount", _g_get_vertexAttributeCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "triangles", _g_get_triangles); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "boneWeights", _g_get_boneWeights); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "indexFormat", _g_get_indexFormat); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "vertexBufferCount", _g_get_vertexBufferCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "vertexBufferTarget", _g_get_vertexBufferTarget); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "indexBufferTarget", _g_get_indexBufferTarget); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "blendShapeCount", _g_get_blendShapeCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bindposes", _g_get_bindposes); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isReadable", _g_get_isReadable); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "vertexCount", _g_get_vertexCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "subMeshCount", _g_get_subMeshCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bounds", _g_get_bounds); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "vertices", _s_set_vertices); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "normals", _s_set_normals); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "tangents", _s_set_tangents); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "uv", _s_set_uv); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "uv2", _s_set_uv2); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "uv3", _s_set_uv3); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "uv4", _s_set_uv4); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "uv5", _s_set_uv5); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "uv6", _s_set_uv6); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "uv7", _s_set_uv7); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "uv8", _s_set_uv8); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "colors", _s_set_colors); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "colors32", _s_set_colors32); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "triangles", _s_set_triangles); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "boneWeights", _s_set_boneWeights); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "indexFormat", _s_set_indexFormat); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "vertexBufferTarget", _s_set_vertexBufferTarget); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "indexBufferTarget", _s_set_indexBufferTarget); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "bindposes", _s_set_bindposes); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "subMeshCount", _s_set_subMeshCount); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "bounds", _s_set_bounds); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 4, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "AcquireReadOnlyMeshData", _m_AcquireReadOnlyMeshData_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "AllocateWritableMeshData", _m_AllocateWritableMeshData_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ApplyAndDisposeWritableMeshData", _m_ApplyAndDisposeWritableMeshData_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 UnityEngine.Mesh(); + 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 UnityEngine.Mesh constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetVertices(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.List _vertices = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetVertices( _vertices ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetVertices(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.List _inVertices = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.SetVertices( _inVertices ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3[] _inVertices = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + + gen_to_be_invoked.SetVertices( _inVertices ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + System.Collections.Generic.List _inVertices = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _start = LuaAPI.xlua_tointeger(L, 3); + int _length = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.SetVertices( _inVertices, _start, _length ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3[] _inVertices = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + int _start = LuaAPI.xlua_tointeger(L, 3); + int _length = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.SetVertices( _inVertices, _start, _length ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + System.Collections.Generic.List _inVertices = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _start = LuaAPI.xlua_tointeger(L, 3); + int _length = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.Rendering.MeshUpdateFlags _flags;translator.Get(L, 5, out _flags); + + gen_to_be_invoked.SetVertices( _inVertices, _start, _length, _flags ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + UnityEngine.Vector3[] _inVertices = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + int _start = LuaAPI.xlua_tointeger(L, 3); + int _length = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.Rendering.MeshUpdateFlags _flags;translator.Get(L, 5, out _flags); + + gen_to_be_invoked.SetVertices( _inVertices, _start, _length, _flags ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Mesh.SetVertices!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetNormals(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.List _normals = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetNormals( _normals ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetNormals(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.List _inNormals = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.SetNormals( _inNormals ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3[] _inNormals = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + + gen_to_be_invoked.SetNormals( _inNormals ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + System.Collections.Generic.List _inNormals = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _start = LuaAPI.xlua_tointeger(L, 3); + int _length = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.SetNormals( _inNormals, _start, _length ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3[] _inNormals = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + int _start = LuaAPI.xlua_tointeger(L, 3); + int _length = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.SetNormals( _inNormals, _start, _length ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + System.Collections.Generic.List _inNormals = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _start = LuaAPI.xlua_tointeger(L, 3); + int _length = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.Rendering.MeshUpdateFlags _flags;translator.Get(L, 5, out _flags); + + gen_to_be_invoked.SetNormals( _inNormals, _start, _length, _flags ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + UnityEngine.Vector3[] _inNormals = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + int _start = LuaAPI.xlua_tointeger(L, 3); + int _length = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.Rendering.MeshUpdateFlags _flags;translator.Get(L, 5, out _flags); + + gen_to_be_invoked.SetNormals( _inNormals, _start, _length, _flags ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Mesh.SetNormals!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetTangents(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.List _tangents = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetTangents( _tangents ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTangents(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.List _inTangents = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.SetTangents( _inTangents ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector4[] _inTangents = (UnityEngine.Vector4[])translator.GetObject(L, 2, typeof(UnityEngine.Vector4[])); + + gen_to_be_invoked.SetTangents( _inTangents ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + System.Collections.Generic.List _inTangents = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _start = LuaAPI.xlua_tointeger(L, 3); + int _length = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.SetTangents( _inTangents, _start, _length ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector4[] _inTangents = (UnityEngine.Vector4[])translator.GetObject(L, 2, typeof(UnityEngine.Vector4[])); + int _start = LuaAPI.xlua_tointeger(L, 3); + int _length = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.SetTangents( _inTangents, _start, _length ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + System.Collections.Generic.List _inTangents = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _start = LuaAPI.xlua_tointeger(L, 3); + int _length = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.Rendering.MeshUpdateFlags _flags;translator.Get(L, 5, out _flags); + + gen_to_be_invoked.SetTangents( _inTangents, _start, _length, _flags ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + UnityEngine.Vector4[] _inTangents = (UnityEngine.Vector4[])translator.GetObject(L, 2, typeof(UnityEngine.Vector4[])); + int _start = LuaAPI.xlua_tointeger(L, 3); + int _length = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.Rendering.MeshUpdateFlags _flags;translator.Get(L, 5, out _flags); + + gen_to_be_invoked.SetTangents( _inTangents, _start, _length, _flags ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Mesh.SetTangents!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetColors(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.List _colors = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetColors( _colors ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.List _colors = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetColors( _colors ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Mesh.GetColors!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetColors(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.List _inColors = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.SetColors( _inColors ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Color[] _inColors = (UnityEngine.Color[])translator.GetObject(L, 2, typeof(UnityEngine.Color[])); + + gen_to_be_invoked.SetColors( _inColors ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.List _inColors = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.SetColors( _inColors ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Color32[] _inColors = (UnityEngine.Color32[])translator.GetObject(L, 2, typeof(UnityEngine.Color32[])); + + gen_to_be_invoked.SetColors( _inColors ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + System.Collections.Generic.List _inColors = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _start = LuaAPI.xlua_tointeger(L, 3); + int _length = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.SetColors( _inColors, _start, _length ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Color[] _inColors = (UnityEngine.Color[])translator.GetObject(L, 2, typeof(UnityEngine.Color[])); + int _start = LuaAPI.xlua_tointeger(L, 3); + int _length = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.SetColors( _inColors, _start, _length ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + System.Collections.Generic.List _inColors = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _start = LuaAPI.xlua_tointeger(L, 3); + int _length = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.SetColors( _inColors, _start, _length ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Color32[] _inColors = (UnityEngine.Color32[])translator.GetObject(L, 2, typeof(UnityEngine.Color32[])); + int _start = LuaAPI.xlua_tointeger(L, 3); + int _length = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.SetColors( _inColors, _start, _length ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + System.Collections.Generic.List _inColors = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _start = LuaAPI.xlua_tointeger(L, 3); + int _length = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.Rendering.MeshUpdateFlags _flags;translator.Get(L, 5, out _flags); + + gen_to_be_invoked.SetColors( _inColors, _start, _length, _flags ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + UnityEngine.Color[] _inColors = (UnityEngine.Color[])translator.GetObject(L, 2, typeof(UnityEngine.Color[])); + int _start = LuaAPI.xlua_tointeger(L, 3); + int _length = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.Rendering.MeshUpdateFlags _flags;translator.Get(L, 5, out _flags); + + gen_to_be_invoked.SetColors( _inColors, _start, _length, _flags ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + System.Collections.Generic.List _inColors = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _start = LuaAPI.xlua_tointeger(L, 3); + int _length = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.Rendering.MeshUpdateFlags _flags;translator.Get(L, 5, out _flags); + + gen_to_be_invoked.SetColors( _inColors, _start, _length, _flags ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + UnityEngine.Color32[] _inColors = (UnityEngine.Color32[])translator.GetObject(L, 2, typeof(UnityEngine.Color32[])); + int _start = LuaAPI.xlua_tointeger(L, 3); + int _length = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.Rendering.MeshUpdateFlags _flags;translator.Get(L, 5, out _flags); + + gen_to_be_invoked.SetColors( _inColors, _start, _length, _flags ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Mesh.SetColors!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetUVs(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _channel = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _uvs = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.SetUVs( _channel, _uvs ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _channel = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _uvs = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.SetUVs( _channel, _uvs ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _channel = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _uvs = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.SetUVs( _channel, _uvs ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _channel = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Vector2[] _uvs = (UnityEngine.Vector2[])translator.GetObject(L, 3, typeof(UnityEngine.Vector2[])); + + gen_to_be_invoked.SetUVs( _channel, _uvs ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _channel = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Vector3[] _uvs = (UnityEngine.Vector3[])translator.GetObject(L, 3, typeof(UnityEngine.Vector3[])); + + gen_to_be_invoked.SetUVs( _channel, _uvs ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _channel = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Vector4[] _uvs = (UnityEngine.Vector4[])translator.GetObject(L, 3, typeof(UnityEngine.Vector4[])); + + gen_to_be_invoked.SetUVs( _channel, _uvs ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int _channel = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _uvs = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + int _start = LuaAPI.xlua_tointeger(L, 4); + int _length = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.SetUVs( _channel, _uvs, _start, _length ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int _channel = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _uvs = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + int _start = LuaAPI.xlua_tointeger(L, 4); + int _length = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.SetUVs( _channel, _uvs, _start, _length ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int _channel = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _uvs = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + int _start = LuaAPI.xlua_tointeger(L, 4); + int _length = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.SetUVs( _channel, _uvs, _start, _length ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int _channel = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Vector2[] _uvs = (UnityEngine.Vector2[])translator.GetObject(L, 3, typeof(UnityEngine.Vector2[])); + int _start = LuaAPI.xlua_tointeger(L, 4); + int _length = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.SetUVs( _channel, _uvs, _start, _length ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int _channel = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Vector3[] _uvs = (UnityEngine.Vector3[])translator.GetObject(L, 3, typeof(UnityEngine.Vector3[])); + int _start = LuaAPI.xlua_tointeger(L, 4); + int _length = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.SetUVs( _channel, _uvs, _start, _length ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int _channel = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Vector4[] _uvs = (UnityEngine.Vector4[])translator.GetObject(L, 3, typeof(UnityEngine.Vector4[])); + int _start = LuaAPI.xlua_tointeger(L, 4); + int _length = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.SetUVs( _channel, _uvs, _start, _length ); + + + + return 0; + } + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)) + { + int _channel = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _uvs = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + int _start = LuaAPI.xlua_tointeger(L, 4); + int _length = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Rendering.MeshUpdateFlags _flags;translator.Get(L, 6, out _flags); + + gen_to_be_invoked.SetUVs( _channel, _uvs, _start, _length, _flags ); + + + + return 0; + } + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)) + { + int _channel = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _uvs = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + int _start = LuaAPI.xlua_tointeger(L, 4); + int _length = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Rendering.MeshUpdateFlags _flags;translator.Get(L, 6, out _flags); + + gen_to_be_invoked.SetUVs( _channel, _uvs, _start, _length, _flags ); + + + + return 0; + } + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)) + { + int _channel = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _uvs = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + int _start = LuaAPI.xlua_tointeger(L, 4); + int _length = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Rendering.MeshUpdateFlags _flags;translator.Get(L, 6, out _flags); + + gen_to_be_invoked.SetUVs( _channel, _uvs, _start, _length, _flags ); + + + + return 0; + } + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)) + { + int _channel = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Vector2[] _uvs = (UnityEngine.Vector2[])translator.GetObject(L, 3, typeof(UnityEngine.Vector2[])); + int _start = LuaAPI.xlua_tointeger(L, 4); + int _length = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Rendering.MeshUpdateFlags _flags;translator.Get(L, 6, out _flags); + + gen_to_be_invoked.SetUVs( _channel, _uvs, _start, _length, _flags ); + + + + return 0; + } + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)) + { + int _channel = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Vector3[] _uvs = (UnityEngine.Vector3[])translator.GetObject(L, 3, typeof(UnityEngine.Vector3[])); + int _start = LuaAPI.xlua_tointeger(L, 4); + int _length = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Rendering.MeshUpdateFlags _flags;translator.Get(L, 6, out _flags); + + gen_to_be_invoked.SetUVs( _channel, _uvs, _start, _length, _flags ); + + + + return 0; + } + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)) + { + int _channel = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Vector4[] _uvs = (UnityEngine.Vector4[])translator.GetObject(L, 3, typeof(UnityEngine.Vector4[])); + int _start = LuaAPI.xlua_tointeger(L, 4); + int _length = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Rendering.MeshUpdateFlags _flags;translator.Get(L, 6, out _flags); + + gen_to_be_invoked.SetUVs( _channel, _uvs, _start, _length, _flags ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Mesh.SetUVs!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetUVs(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _channel = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _uvs = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetUVs( _channel, _uvs ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _channel = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _uvs = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetUVs( _channel, _uvs ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _channel = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _uvs = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetUVs( _channel, _uvs ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Mesh.GetUVs!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetVertexAttributes(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.GetVertexAttributes( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Rendering.VertexAttributeDescriptor[] _attributes = (UnityEngine.Rendering.VertexAttributeDescriptor[])translator.GetObject(L, 2, typeof(UnityEngine.Rendering.VertexAttributeDescriptor[])); + + var gen_ret = gen_to_be_invoked.GetVertexAttributes( _attributes ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.List _attributes = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + var gen_ret = gen_to_be_invoked.GetVertexAttributes( _attributes ); + LuaAPI.xlua_pushinteger(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 UnityEngine.Mesh.GetVertexAttributes!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetVertexBufferParams(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count >= 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 3) || translator.Assignable(L, 3))) + { + int _vertexCount = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Rendering.VertexAttributeDescriptor[] _attributes = translator.GetParams(L, 3); + + gen_to_be_invoked.SetVertexBufferParams( _vertexCount, _attributes ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _vertexCount = LuaAPI.xlua_tointeger(L, 2); + Unity.Collections.NativeArray _attributes;translator.Get(L, 3, out _attributes); + + gen_to_be_invoked.SetVertexBufferParams( _vertexCount, _attributes ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Mesh.SetVertexBufferParams!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AcquireReadOnlyMeshData_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 1, typeof(UnityEngine.Mesh)); + + var gen_ret = UnityEngine.Mesh.AcquireReadOnlyMeshData( _mesh ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + UnityEngine.Mesh[] _meshes = (UnityEngine.Mesh[])translator.GetObject(L, 1, typeof(UnityEngine.Mesh[])); + + var gen_ret = UnityEngine.Mesh.AcquireReadOnlyMeshData( _meshes ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable>(L, 1)) + { + System.Collections.Generic.List _meshes = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + + var gen_ret = UnityEngine.Mesh.AcquireReadOnlyMeshData( _meshes ); + 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 UnityEngine.Mesh.AcquireReadOnlyMeshData!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AllocateWritableMeshData_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + int _meshCount = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = UnityEngine.Mesh.AllocateWritableMeshData( _meshCount ); + 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_ApplyAndDisposeWritableMeshData_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Mesh.MeshDataArray _data;translator.Get(L, 1, out _data); + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + UnityEngine.Rendering.MeshUpdateFlags _flags;translator.Get(L, 3, out _flags); + + UnityEngine.Mesh.ApplyAndDisposeWritableMeshData( _data, _mesh, _flags ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.Mesh.MeshDataArray _data;translator.Get(L, 1, out _data); + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + + UnityEngine.Mesh.ApplyAndDisposeWritableMeshData( _data, _mesh ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Mesh.MeshDataArray _data;translator.Get(L, 1, out _data); + UnityEngine.Mesh[] _meshes = (UnityEngine.Mesh[])translator.GetObject(L, 2, typeof(UnityEngine.Mesh[])); + UnityEngine.Rendering.MeshUpdateFlags _flags;translator.Get(L, 3, out _flags); + + UnityEngine.Mesh.ApplyAndDisposeWritableMeshData( _data, _meshes, _flags ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.Mesh.MeshDataArray _data;translator.Get(L, 1, out _data); + UnityEngine.Mesh[] _meshes = (UnityEngine.Mesh[])translator.GetObject(L, 2, typeof(UnityEngine.Mesh[])); + + UnityEngine.Mesh.ApplyAndDisposeWritableMeshData( _data, _meshes ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Mesh.MeshDataArray _data;translator.Get(L, 1, out _data); + System.Collections.Generic.List _meshes = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + UnityEngine.Rendering.MeshUpdateFlags _flags;translator.Get(L, 3, out _flags); + + UnityEngine.Mesh.ApplyAndDisposeWritableMeshData( _data, _meshes, _flags ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable>(L, 2)) + { + UnityEngine.Mesh.MeshDataArray _data;translator.Get(L, 1, out _data); + System.Collections.Generic.List _meshes = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + UnityEngine.Mesh.ApplyAndDisposeWritableMeshData( _data, _meshes ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Mesh.ApplyAndDisposeWritableMeshData!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetVertexBuffer(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetVertexBuffer( _index ); + 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_GetIndexBuffer(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetIndexBuffer( ); + 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_GetTriangles(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _submesh = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetTriangles( _submesh ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + int _submesh = LuaAPI.xlua_tointeger(L, 2); + bool _applyBaseVertex = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.GetTriangles( _submesh, _applyBaseVertex ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + System.Collections.Generic.List _triangles = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _submesh = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.GetTriangles( _triangles, _submesh ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + System.Collections.Generic.List _triangles = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _submesh = LuaAPI.xlua_tointeger(L, 3); + bool _applyBaseVertex = LuaAPI.lua_toboolean(L, 4); + + gen_to_be_invoked.GetTriangles( _triangles, _submesh, _applyBaseVertex ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + System.Collections.Generic.List _triangles = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _submesh = LuaAPI.xlua_tointeger(L, 3); + bool _applyBaseVertex = LuaAPI.lua_toboolean(L, 4); + + gen_to_be_invoked.GetTriangles( _triangles, _submesh, _applyBaseVertex ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + System.Collections.Generic.List _triangles = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _submesh = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.GetTriangles( _triangles, _submesh ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Mesh.GetTriangles!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetIndices(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _submesh = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetIndices( _submesh ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + int _submesh = LuaAPI.xlua_tointeger(L, 2); + bool _applyBaseVertex = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.GetIndices( _submesh, _applyBaseVertex ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + System.Collections.Generic.List _indices = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _submesh = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.GetIndices( _indices, _submesh ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + System.Collections.Generic.List _indices = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _submesh = LuaAPI.xlua_tointeger(L, 3); + bool _applyBaseVertex = LuaAPI.lua_toboolean(L, 4); + + gen_to_be_invoked.GetIndices( _indices, _submesh, _applyBaseVertex ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + System.Collections.Generic.List _indices = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _submesh = LuaAPI.xlua_tointeger(L, 3); + bool _applyBaseVertex = LuaAPI.lua_toboolean(L, 4); + + gen_to_be_invoked.GetIndices( _indices, _submesh, _applyBaseVertex ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + System.Collections.Generic.List _indices = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _submesh = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.GetIndices( _indices, _submesh ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Mesh.GetIndices!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetIndexStart(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + int _submesh = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetIndexStart( _submesh ); + LuaAPI.xlua_pushuint(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_GetIndexCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + int _submesh = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetIndexCount( _submesh ); + LuaAPI.xlua_pushuint(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_GetBaseVertex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + int _submesh = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetBaseVertex( _submesh ); + LuaAPI.xlua_pushuint(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_SetTriangles(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int[] _triangles = (int[])translator.GetObject(L, 2, typeof(int[])); + int _submesh = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetTriangles( _triangles, _submesh ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + System.Collections.Generic.List _triangles = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _submesh = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetTriangles( _triangles, _submesh ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + int[] _triangles = (int[])translator.GetObject(L, 2, typeof(int[])); + int _submesh = LuaAPI.xlua_tointeger(L, 3); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 4); + + gen_to_be_invoked.SetTriangles( _triangles, _submesh, _calculateBounds ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + System.Collections.Generic.List _triangles = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _submesh = LuaAPI.xlua_tointeger(L, 3); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 4); + + gen_to_be_invoked.SetTriangles( _triangles, _submesh, _calculateBounds ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int[] _triangles = (int[])translator.GetObject(L, 2, typeof(int[])); + int _submesh = LuaAPI.xlua_tointeger(L, 3); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 4); + int _baseVertex = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.SetTriangles( _triangles, _submesh, _calculateBounds, _baseVertex ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + ushort[] _triangles = (ushort[])translator.GetObject(L, 2, typeof(ushort[])); + int _submesh = LuaAPI.xlua_tointeger(L, 3); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 4); + int _baseVertex = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.SetTriangles( _triangles, _submesh, _calculateBounds, _baseVertex ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + ushort[] _triangles = (ushort[])translator.GetObject(L, 2, typeof(ushort[])); + int _submesh = LuaAPI.xlua_tointeger(L, 3); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 4); + + gen_to_be_invoked.SetTriangles( _triangles, _submesh, _calculateBounds ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + ushort[] _triangles = (ushort[])translator.GetObject(L, 2, typeof(ushort[])); + int _submesh = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetTriangles( _triangles, _submesh ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + System.Collections.Generic.List _triangles = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _submesh = LuaAPI.xlua_tointeger(L, 3); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 4); + int _baseVertex = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.SetTriangles( _triangles, _submesh, _calculateBounds, _baseVertex ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + System.Collections.Generic.List _triangles = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _submesh = LuaAPI.xlua_tointeger(L, 3); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 4); + int _baseVertex = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.SetTriangles( _triangles, _submesh, _calculateBounds, _baseVertex ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + System.Collections.Generic.List _triangles = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _submesh = LuaAPI.xlua_tointeger(L, 3); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 4); + + gen_to_be_invoked.SetTriangles( _triangles, _submesh, _calculateBounds ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + System.Collections.Generic.List _triangles = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _submesh = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetTriangles( _triangles, _submesh ); + + + + return 0; + } + if(gen_param_count == 7&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)) + { + int[] _triangles = (int[])translator.GetObject(L, 2, typeof(int[])); + int _trianglesStart = LuaAPI.xlua_tointeger(L, 3); + int _trianglesLength = LuaAPI.xlua_tointeger(L, 4); + int _submesh = LuaAPI.xlua_tointeger(L, 5); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 6); + int _baseVertex = LuaAPI.xlua_tointeger(L, 7); + + gen_to_be_invoked.SetTriangles( _triangles, _trianglesStart, _trianglesLength, _submesh, _calculateBounds, _baseVertex ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)) + { + int[] _triangles = (int[])translator.GetObject(L, 2, typeof(int[])); + int _trianglesStart = LuaAPI.xlua_tointeger(L, 3); + int _trianglesLength = LuaAPI.xlua_tointeger(L, 4); + int _submesh = LuaAPI.xlua_tointeger(L, 5); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 6); + + gen_to_be_invoked.SetTriangles( _triangles, _trianglesStart, _trianglesLength, _submesh, _calculateBounds ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int[] _triangles = (int[])translator.GetObject(L, 2, typeof(int[])); + int _trianglesStart = LuaAPI.xlua_tointeger(L, 3); + int _trianglesLength = LuaAPI.xlua_tointeger(L, 4); + int _submesh = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.SetTriangles( _triangles, _trianglesStart, _trianglesLength, _submesh ); + + + + return 0; + } + if(gen_param_count == 7&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)) + { + ushort[] _triangles = (ushort[])translator.GetObject(L, 2, typeof(ushort[])); + int _trianglesStart = LuaAPI.xlua_tointeger(L, 3); + int _trianglesLength = LuaAPI.xlua_tointeger(L, 4); + int _submesh = LuaAPI.xlua_tointeger(L, 5); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 6); + int _baseVertex = LuaAPI.xlua_tointeger(L, 7); + + gen_to_be_invoked.SetTriangles( _triangles, _trianglesStart, _trianglesLength, _submesh, _calculateBounds, _baseVertex ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)) + { + ushort[] _triangles = (ushort[])translator.GetObject(L, 2, typeof(ushort[])); + int _trianglesStart = LuaAPI.xlua_tointeger(L, 3); + int _trianglesLength = LuaAPI.xlua_tointeger(L, 4); + int _submesh = LuaAPI.xlua_tointeger(L, 5); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 6); + + gen_to_be_invoked.SetTriangles( _triangles, _trianglesStart, _trianglesLength, _submesh, _calculateBounds ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + ushort[] _triangles = (ushort[])translator.GetObject(L, 2, typeof(ushort[])); + int _trianglesStart = LuaAPI.xlua_tointeger(L, 3); + int _trianglesLength = LuaAPI.xlua_tointeger(L, 4); + int _submesh = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.SetTriangles( _triangles, _trianglesStart, _trianglesLength, _submesh ); + + + + return 0; + } + if(gen_param_count == 7&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)) + { + System.Collections.Generic.List _triangles = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _trianglesStart = LuaAPI.xlua_tointeger(L, 3); + int _trianglesLength = LuaAPI.xlua_tointeger(L, 4); + int _submesh = LuaAPI.xlua_tointeger(L, 5); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 6); + int _baseVertex = LuaAPI.xlua_tointeger(L, 7); + + gen_to_be_invoked.SetTriangles( _triangles, _trianglesStart, _trianglesLength, _submesh, _calculateBounds, _baseVertex ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)) + { + System.Collections.Generic.List _triangles = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _trianglesStart = LuaAPI.xlua_tointeger(L, 3); + int _trianglesLength = LuaAPI.xlua_tointeger(L, 4); + int _submesh = LuaAPI.xlua_tointeger(L, 5); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 6); + + gen_to_be_invoked.SetTriangles( _triangles, _trianglesStart, _trianglesLength, _submesh, _calculateBounds ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + System.Collections.Generic.List _triangles = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _trianglesStart = LuaAPI.xlua_tointeger(L, 3); + int _trianglesLength = LuaAPI.xlua_tointeger(L, 4); + int _submesh = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.SetTriangles( _triangles, _trianglesStart, _trianglesLength, _submesh ); + + + + return 0; + } + if(gen_param_count == 7&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)) + { + System.Collections.Generic.List _triangles = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _trianglesStart = LuaAPI.xlua_tointeger(L, 3); + int _trianglesLength = LuaAPI.xlua_tointeger(L, 4); + int _submesh = LuaAPI.xlua_tointeger(L, 5); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 6); + int _baseVertex = LuaAPI.xlua_tointeger(L, 7); + + gen_to_be_invoked.SetTriangles( _triangles, _trianglesStart, _trianglesLength, _submesh, _calculateBounds, _baseVertex ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)) + { + System.Collections.Generic.List _triangles = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _trianglesStart = LuaAPI.xlua_tointeger(L, 3); + int _trianglesLength = LuaAPI.xlua_tointeger(L, 4); + int _submesh = LuaAPI.xlua_tointeger(L, 5); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 6); + + gen_to_be_invoked.SetTriangles( _triangles, _trianglesStart, _trianglesLength, _submesh, _calculateBounds ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + System.Collections.Generic.List _triangles = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _trianglesStart = LuaAPI.xlua_tointeger(L, 3); + int _trianglesLength = LuaAPI.xlua_tointeger(L, 4); + int _submesh = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.SetTriangles( _triangles, _trianglesStart, _trianglesLength, _submesh ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Mesh.SetTriangles!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetIndices(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + int[] _indices = (int[])translator.GetObject(L, 2, typeof(int[])); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + int _submesh = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.SetIndices( _indices, _topology, _submesh ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)) + { + int[] _indices = (int[])translator.GetObject(L, 2, typeof(int[])); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + int _submesh = LuaAPI.xlua_tointeger(L, 4); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 5); + + gen_to_be_invoked.SetIndices( _indices, _topology, _submesh, _calculateBounds ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + int[] _indices = (int[])translator.GetObject(L, 2, typeof(int[])); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + int _submesh = LuaAPI.xlua_tointeger(L, 4); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 5); + int _baseVertex = LuaAPI.xlua_tointeger(L, 6); + + gen_to_be_invoked.SetIndices( _indices, _topology, _submesh, _calculateBounds, _baseVertex ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + ushort[] _indices = (ushort[])translator.GetObject(L, 2, typeof(ushort[])); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + int _submesh = LuaAPI.xlua_tointeger(L, 4); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 5); + int _baseVertex = LuaAPI.xlua_tointeger(L, 6); + + gen_to_be_invoked.SetIndices( _indices, _topology, _submesh, _calculateBounds, _baseVertex ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)) + { + ushort[] _indices = (ushort[])translator.GetObject(L, 2, typeof(ushort[])); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + int _submesh = LuaAPI.xlua_tointeger(L, 4); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 5); + + gen_to_be_invoked.SetIndices( _indices, _topology, _submesh, _calculateBounds ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + ushort[] _indices = (ushort[])translator.GetObject(L, 2, typeof(ushort[])); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + int _submesh = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.SetIndices( _indices, _topology, _submesh ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + System.Collections.Generic.List _indices = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + int _submesh = LuaAPI.xlua_tointeger(L, 4); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 5); + int _baseVertex = LuaAPI.xlua_tointeger(L, 6); + + gen_to_be_invoked.SetIndices( _indices, _topology, _submesh, _calculateBounds, _baseVertex ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)) + { + System.Collections.Generic.List _indices = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + int _submesh = LuaAPI.xlua_tointeger(L, 4); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 5); + + gen_to_be_invoked.SetIndices( _indices, _topology, _submesh, _calculateBounds ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + System.Collections.Generic.List _indices = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + int _submesh = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.SetIndices( _indices, _topology, _submesh ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + System.Collections.Generic.List _indices = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + int _submesh = LuaAPI.xlua_tointeger(L, 4); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 5); + int _baseVertex = LuaAPI.xlua_tointeger(L, 6); + + gen_to_be_invoked.SetIndices( _indices, _topology, _submesh, _calculateBounds, _baseVertex ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)) + { + System.Collections.Generic.List _indices = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + int _submesh = LuaAPI.xlua_tointeger(L, 4); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 5); + + gen_to_be_invoked.SetIndices( _indices, _topology, _submesh, _calculateBounds ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + System.Collections.Generic.List _indices = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + UnityEngine.MeshTopology _topology;translator.Get(L, 3, out _topology); + int _submesh = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.SetIndices( _indices, _topology, _submesh ); + + + + return 0; + } + if(gen_param_count == 8&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 7)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 8)) + { + int[] _indices = (int[])translator.GetObject(L, 2, typeof(int[])); + int _indicesStart = LuaAPI.xlua_tointeger(L, 3); + int _indicesLength = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.MeshTopology _topology;translator.Get(L, 5, out _topology); + int _submesh = LuaAPI.xlua_tointeger(L, 6); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 7); + int _baseVertex = LuaAPI.xlua_tointeger(L, 8); + + gen_to_be_invoked.SetIndices( _indices, _indicesStart, _indicesLength, _topology, _submesh, _calculateBounds, _baseVertex ); + + + + return 0; + } + if(gen_param_count == 7&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 7)) + { + int[] _indices = (int[])translator.GetObject(L, 2, typeof(int[])); + int _indicesStart = LuaAPI.xlua_tointeger(L, 3); + int _indicesLength = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.MeshTopology _topology;translator.Get(L, 5, out _topology); + int _submesh = LuaAPI.xlua_tointeger(L, 6); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 7); + + gen_to_be_invoked.SetIndices( _indices, _indicesStart, _indicesLength, _topology, _submesh, _calculateBounds ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + int[] _indices = (int[])translator.GetObject(L, 2, typeof(int[])); + int _indicesStart = LuaAPI.xlua_tointeger(L, 3); + int _indicesLength = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.MeshTopology _topology;translator.Get(L, 5, out _topology); + int _submesh = LuaAPI.xlua_tointeger(L, 6); + + gen_to_be_invoked.SetIndices( _indices, _indicesStart, _indicesLength, _topology, _submesh ); + + + + return 0; + } + if(gen_param_count == 8&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 7)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 8)) + { + ushort[] _indices = (ushort[])translator.GetObject(L, 2, typeof(ushort[])); + int _indicesStart = LuaAPI.xlua_tointeger(L, 3); + int _indicesLength = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.MeshTopology _topology;translator.Get(L, 5, out _topology); + int _submesh = LuaAPI.xlua_tointeger(L, 6); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 7); + int _baseVertex = LuaAPI.xlua_tointeger(L, 8); + + gen_to_be_invoked.SetIndices( _indices, _indicesStart, _indicesLength, _topology, _submesh, _calculateBounds, _baseVertex ); + + + + return 0; + } + if(gen_param_count == 7&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 7)) + { + ushort[] _indices = (ushort[])translator.GetObject(L, 2, typeof(ushort[])); + int _indicesStart = LuaAPI.xlua_tointeger(L, 3); + int _indicesLength = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.MeshTopology _topology;translator.Get(L, 5, out _topology); + int _submesh = LuaAPI.xlua_tointeger(L, 6); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 7); + + gen_to_be_invoked.SetIndices( _indices, _indicesStart, _indicesLength, _topology, _submesh, _calculateBounds ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + ushort[] _indices = (ushort[])translator.GetObject(L, 2, typeof(ushort[])); + int _indicesStart = LuaAPI.xlua_tointeger(L, 3); + int _indicesLength = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.MeshTopology _topology;translator.Get(L, 5, out _topology); + int _submesh = LuaAPI.xlua_tointeger(L, 6); + + gen_to_be_invoked.SetIndices( _indices, _indicesStart, _indicesLength, _topology, _submesh ); + + + + return 0; + } + if(gen_param_count == 8&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 7)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 8)) + { + System.Collections.Generic.List _indices = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _indicesStart = LuaAPI.xlua_tointeger(L, 3); + int _indicesLength = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.MeshTopology _topology;translator.Get(L, 5, out _topology); + int _submesh = LuaAPI.xlua_tointeger(L, 6); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 7); + int _baseVertex = LuaAPI.xlua_tointeger(L, 8); + + gen_to_be_invoked.SetIndices( _indices, _indicesStart, _indicesLength, _topology, _submesh, _calculateBounds, _baseVertex ); + + + + return 0; + } + if(gen_param_count == 7&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 7)) + { + System.Collections.Generic.List _indices = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _indicesStart = LuaAPI.xlua_tointeger(L, 3); + int _indicesLength = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.MeshTopology _topology;translator.Get(L, 5, out _topology); + int _submesh = LuaAPI.xlua_tointeger(L, 6); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 7); + + gen_to_be_invoked.SetIndices( _indices, _indicesStart, _indicesLength, _topology, _submesh, _calculateBounds ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + System.Collections.Generic.List _indices = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _indicesStart = LuaAPI.xlua_tointeger(L, 3); + int _indicesLength = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.MeshTopology _topology;translator.Get(L, 5, out _topology); + int _submesh = LuaAPI.xlua_tointeger(L, 6); + + gen_to_be_invoked.SetIndices( _indices, _indicesStart, _indicesLength, _topology, _submesh ); + + + + return 0; + } + if(gen_param_count == 8&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 7)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 8)) + { + System.Collections.Generic.List _indices = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _indicesStart = LuaAPI.xlua_tointeger(L, 3); + int _indicesLength = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.MeshTopology _topology;translator.Get(L, 5, out _topology); + int _submesh = LuaAPI.xlua_tointeger(L, 6); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 7); + int _baseVertex = LuaAPI.xlua_tointeger(L, 8); + + gen_to_be_invoked.SetIndices( _indices, _indicesStart, _indicesLength, _topology, _submesh, _calculateBounds, _baseVertex ); + + + + return 0; + } + if(gen_param_count == 7&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 7)) + { + System.Collections.Generic.List _indices = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _indicesStart = LuaAPI.xlua_tointeger(L, 3); + int _indicesLength = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.MeshTopology _topology;translator.Get(L, 5, out _topology); + int _submesh = LuaAPI.xlua_tointeger(L, 6); + bool _calculateBounds = LuaAPI.lua_toboolean(L, 7); + + gen_to_be_invoked.SetIndices( _indices, _indicesStart, _indicesLength, _topology, _submesh, _calculateBounds ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + System.Collections.Generic.List _indices = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _indicesStart = LuaAPI.xlua_tointeger(L, 3); + int _indicesLength = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.MeshTopology _topology;translator.Get(L, 5, out _topology); + int _submesh = LuaAPI.xlua_tointeger(L, 6); + + gen_to_be_invoked.SetIndices( _indices, _indicesStart, _indicesLength, _topology, _submesh ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Mesh.SetIndices!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSubMeshes(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Rendering.SubMeshDescriptor[] _desc = (UnityEngine.Rendering.SubMeshDescriptor[])translator.GetObject(L, 2, typeof(UnityEngine.Rendering.SubMeshDescriptor[])); + UnityEngine.Rendering.MeshUpdateFlags _flags;translator.Get(L, 3, out _flags); + + gen_to_be_invoked.SetSubMeshes( _desc, _flags ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Rendering.SubMeshDescriptor[] _desc = (UnityEngine.Rendering.SubMeshDescriptor[])translator.GetObject(L, 2, typeof(UnityEngine.Rendering.SubMeshDescriptor[])); + + gen_to_be_invoked.SetSubMeshes( _desc ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable>(L, 2)&& translator.Assignable(L, 3)) + { + System.Collections.Generic.List _desc = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + UnityEngine.Rendering.MeshUpdateFlags _flags;translator.Get(L, 3, out _flags); + + gen_to_be_invoked.SetSubMeshes( _desc, _flags ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.List _desc = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.SetSubMeshes( _desc ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + UnityEngine.Rendering.SubMeshDescriptor[] _desc = (UnityEngine.Rendering.SubMeshDescriptor[])translator.GetObject(L, 2, typeof(UnityEngine.Rendering.SubMeshDescriptor[])); + int _start = LuaAPI.xlua_tointeger(L, 3); + int _count = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.Rendering.MeshUpdateFlags _flags;translator.Get(L, 5, out _flags); + + gen_to_be_invoked.SetSubMeshes( _desc, _start, _count, _flags ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Rendering.SubMeshDescriptor[] _desc = (UnityEngine.Rendering.SubMeshDescriptor[])translator.GetObject(L, 2, typeof(UnityEngine.Rendering.SubMeshDescriptor[])); + int _start = LuaAPI.xlua_tointeger(L, 3); + int _count = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.SetSubMeshes( _desc, _start, _count ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + System.Collections.Generic.List _desc = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _start = LuaAPI.xlua_tointeger(L, 3); + int _count = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.Rendering.MeshUpdateFlags _flags;translator.Get(L, 5, out _flags); + + gen_to_be_invoked.SetSubMeshes( _desc, _start, _count, _flags ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + System.Collections.Generic.List _desc = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + int _start = LuaAPI.xlua_tointeger(L, 3); + int _count = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.SetSubMeshes( _desc, _start, _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Mesh.SetSubMeshes!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetBindposes(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.List _bindposes = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetBindposes( _bindposes ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetBoneWeights(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.List _boneWeights = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetBoneWeights( _boneWeights ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Clear(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.Clear( ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _keepVertexLayout = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.Clear( _keepVertexLayout ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Mesh.Clear!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RecalculateBounds(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.RecalculateBounds( ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Rendering.MeshUpdateFlags _flags;translator.Get(L, 2, out _flags); + + gen_to_be_invoked.RecalculateBounds( _flags ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Mesh.RecalculateBounds!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RecalculateNormals(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.RecalculateNormals( ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Rendering.MeshUpdateFlags _flags;translator.Get(L, 2, out _flags); + + gen_to_be_invoked.RecalculateNormals( _flags ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Mesh.RecalculateNormals!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RecalculateTangents(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.RecalculateTangents( ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Rendering.MeshUpdateFlags _flags;translator.Get(L, 2, out _flags); + + gen_to_be_invoked.RecalculateTangents( _flags ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Mesh.RecalculateTangents!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RecalculateUVDistributionMetric(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _uvSetIndex = LuaAPI.xlua_tointeger(L, 2); + float _uvAreaThreshold = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.RecalculateUVDistributionMetric( _uvSetIndex, _uvAreaThreshold ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _uvSetIndex = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.RecalculateUVDistributionMetric( _uvSetIndex ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Mesh.RecalculateUVDistributionMetric!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RecalculateUVDistributionMetrics(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _uvAreaThreshold = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.RecalculateUVDistributionMetrics( _uvAreaThreshold ); + + + + return 0; + } + if(gen_param_count == 1) + { + + gen_to_be_invoked.RecalculateUVDistributionMetrics( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Mesh.RecalculateUVDistributionMetrics!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_MarkDynamic(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.MarkDynamic( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UploadMeshData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + bool _markNoLongerReadable = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.UploadMeshData( _markNoLongerReadable ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Optimize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Optimize( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OptimizeIndexBuffers(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.OptimizeIndexBuffers( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OptimizeReorderVertexBuffer(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.OptimizeReorderVertexBuffer( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetTopology(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + int _submesh = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetTopology( _submesh ); + 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_CombineMeshes(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.CombineInstance[] _combine = (UnityEngine.CombineInstance[])translator.GetObject(L, 2, typeof(UnityEngine.CombineInstance[])); + + gen_to_be_invoked.CombineMeshes( _combine ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + UnityEngine.CombineInstance[] _combine = (UnityEngine.CombineInstance[])translator.GetObject(L, 2, typeof(UnityEngine.CombineInstance[])); + bool _mergeSubMeshes = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.CombineMeshes( _combine, _mergeSubMeshes ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + UnityEngine.CombineInstance[] _combine = (UnityEngine.CombineInstance[])translator.GetObject(L, 2, typeof(UnityEngine.CombineInstance[])); + bool _mergeSubMeshes = LuaAPI.lua_toboolean(L, 3); + bool _useMatrices = LuaAPI.lua_toboolean(L, 4); + + gen_to_be_invoked.CombineMeshes( _combine, _mergeSubMeshes, _useMatrices ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)) + { + UnityEngine.CombineInstance[] _combine = (UnityEngine.CombineInstance[])translator.GetObject(L, 2, typeof(UnityEngine.CombineInstance[])); + bool _mergeSubMeshes = LuaAPI.lua_toboolean(L, 3); + bool _useMatrices = LuaAPI.lua_toboolean(L, 4); + bool _hasLightmapData = LuaAPI.lua_toboolean(L, 5); + + gen_to_be_invoked.CombineMeshes( _combine, _mergeSubMeshes, _useMatrices, _hasLightmapData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Mesh.CombineMeshes!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetIndexBufferParams(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + int _indexCount = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Rendering.IndexFormat _format;translator.Get(L, 3, out _format); + + gen_to_be_invoked.SetIndexBufferParams( _indexCount, _format ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetVertexAttribute(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetVertexAttribute( _index ); + 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_HasVertexAttribute(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Rendering.VertexAttribute _attr;translator.Get(L, 2, out _attr); + + var gen_ret = gen_to_be_invoked.HasVertexAttribute( _attr ); + 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_GetVertexAttributeDimension(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Rendering.VertexAttribute _attr;translator.Get(L, 2, out _attr); + + var gen_ret = gen_to_be_invoked.GetVertexAttributeDimension( _attr ); + 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_GetVertexAttributeFormat(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Rendering.VertexAttribute _attr;translator.Get(L, 2, out _attr); + + var gen_ret = gen_to_be_invoked.GetVertexAttributeFormat( _attr ); + 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_GetVertexAttributeStream(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Rendering.VertexAttribute _attr;translator.Get(L, 2, out _attr); + + var gen_ret = gen_to_be_invoked.GetVertexAttributeStream( _attr ); + 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_GetVertexAttributeOffset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Rendering.VertexAttribute _attr;translator.Get(L, 2, out _attr); + + var gen_ret = gen_to_be_invoked.GetVertexAttributeOffset( _attr ); + 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_GetVertexBufferStride(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + int _stream = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetVertexBufferStride( _stream ); + 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_GetNativeVertexBufferPtr(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetNativeVertexBufferPtr( _index ); + LuaAPI.lua_pushlightuserdata(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_GetNativeIndexBufferPtr(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetNativeIndexBufferPtr( ); + LuaAPI.lua_pushlightuserdata(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_ClearBlendShapes(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearBlendShapes( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetBlendShapeName(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + int _shapeIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetBlendShapeName( _shapeIndex ); + 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 _m_GetBlendShapeIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + string _blendShapeName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetBlendShapeIndex( _blendShapeName ); + 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_GetBlendShapeFrameCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + int _shapeIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetBlendShapeFrameCount( _shapeIndex ); + 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_GetBlendShapeFrameWeight(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + int _shapeIndex = LuaAPI.xlua_tointeger(L, 2); + int _frameIndex = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.GetBlendShapeFrameWeight( _shapeIndex, _frameIndex ); + LuaAPI.lua_pushnumber(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_GetBlendShapeFrameVertices(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + int _shapeIndex = LuaAPI.xlua_tointeger(L, 2); + int _frameIndex = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.Vector3[] _deltaVertices = (UnityEngine.Vector3[])translator.GetObject(L, 4, typeof(UnityEngine.Vector3[])); + UnityEngine.Vector3[] _deltaNormals = (UnityEngine.Vector3[])translator.GetObject(L, 5, typeof(UnityEngine.Vector3[])); + UnityEngine.Vector3[] _deltaTangents = (UnityEngine.Vector3[])translator.GetObject(L, 6, typeof(UnityEngine.Vector3[])); + + gen_to_be_invoked.GetBlendShapeFrameVertices( _shapeIndex, _frameIndex, _deltaVertices, _deltaNormals, _deltaTangents ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddBlendShapeFrame(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + string _shapeName = LuaAPI.lua_tostring(L, 2); + float _frameWeight = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Vector3[] _deltaVertices = (UnityEngine.Vector3[])translator.GetObject(L, 4, typeof(UnityEngine.Vector3[])); + UnityEngine.Vector3[] _deltaNormals = (UnityEngine.Vector3[])translator.GetObject(L, 5, typeof(UnityEngine.Vector3[])); + UnityEngine.Vector3[] _deltaTangents = (UnityEngine.Vector3[])translator.GetObject(L, 6, typeof(UnityEngine.Vector3[])); + + gen_to_be_invoked.AddBlendShapeFrame( _shapeName, _frameWeight, _deltaVertices, _deltaNormals, _deltaTangents ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetBoneWeights(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + Unity.Collections.NativeArray _bonesPerVertex;translator.Get(L, 2, out _bonesPerVertex); + Unity.Collections.NativeArray _weights;translator.Get(L, 3, out _weights); + + gen_to_be_invoked.SetBoneWeights( _bonesPerVertex, _weights ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetAllBoneWeights(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetAllBoneWeights( ); + 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_GetBonesPerVertex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetBonesPerVertex( ); + 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_SetSubMesh(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Rendering.SubMeshDescriptor _desc;translator.Get(L, 3, out _desc); + UnityEngine.Rendering.MeshUpdateFlags _flags;translator.Get(L, 4, out _flags); + + gen_to_be_invoked.SetSubMesh( _index, _desc, _flags ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Rendering.SubMeshDescriptor _desc;translator.Get(L, 3, out _desc); + + gen_to_be_invoked.SetSubMesh( _index, _desc ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Mesh.SetSubMesh!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetSubMesh(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetSubMesh( _index ); + 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_MarkModified(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.MarkModified( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetUVDistributionMetric(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + + + + { + int _uvSetIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetUVDistributionMetric( _uvSetIndex ); + LuaAPI.lua_pushnumber(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_vertices(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.vertices); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_normals(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.normals); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_tangents(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.tangents); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_uv(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.uv); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_uv2(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.uv2); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_uv3(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.uv3); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_uv4(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.uv4); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_uv5(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.uv5); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_uv6(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.uv6); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_uv7(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.uv7); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_uv8(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.uv8); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_colors(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.colors); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_colors32(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.colors32); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_vertexAttributeCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.vertexAttributeCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_triangles(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.triangles); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_boneWeights(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.boneWeights); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_indexFormat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.indexFormat); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_vertexBufferCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.vertexBufferCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_vertexBufferTarget(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.vertexBufferTarget); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_indexBufferTarget(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.indexBufferTarget); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_blendShapeCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.blendShapeCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bindposes(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.bindposes); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isReadable(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isReadable); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_vertexCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.vertexCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_subMeshCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.subMeshCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bounds(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineBounds(L, gen_to_be_invoked.bounds); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_vertices(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.vertices = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_normals(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.normals = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_tangents(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.tangents = (UnityEngine.Vector4[])translator.GetObject(L, 2, typeof(UnityEngine.Vector4[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_uv(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.uv = (UnityEngine.Vector2[])translator.GetObject(L, 2, typeof(UnityEngine.Vector2[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_uv2(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.uv2 = (UnityEngine.Vector2[])translator.GetObject(L, 2, typeof(UnityEngine.Vector2[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_uv3(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.uv3 = (UnityEngine.Vector2[])translator.GetObject(L, 2, typeof(UnityEngine.Vector2[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_uv4(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.uv4 = (UnityEngine.Vector2[])translator.GetObject(L, 2, typeof(UnityEngine.Vector2[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_uv5(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.uv5 = (UnityEngine.Vector2[])translator.GetObject(L, 2, typeof(UnityEngine.Vector2[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_uv6(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.uv6 = (UnityEngine.Vector2[])translator.GetObject(L, 2, typeof(UnityEngine.Vector2[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_uv7(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.uv7 = (UnityEngine.Vector2[])translator.GetObject(L, 2, typeof(UnityEngine.Vector2[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_uv8(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.uv8 = (UnityEngine.Vector2[])translator.GetObject(L, 2, typeof(UnityEngine.Vector2[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_colors(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.colors = (UnityEngine.Color[])translator.GetObject(L, 2, typeof(UnityEngine.Color[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_colors32(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.colors32 = (UnityEngine.Color32[])translator.GetObject(L, 2, typeof(UnityEngine.Color32[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_triangles(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.triangles = (int[])translator.GetObject(L, 2, typeof(int[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_boneWeights(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.boneWeights = (UnityEngine.BoneWeight[])translator.GetObject(L, 2, typeof(UnityEngine.BoneWeight[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_indexFormat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + UnityEngine.Rendering.IndexFormat gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.indexFormat = 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_vertexBufferTarget(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + UnityEngine.GraphicsBuffer.Target gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.vertexBufferTarget = 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_indexBufferTarget(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + UnityEngine.GraphicsBuffer.Target gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.indexBufferTarget = 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_bindposes(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.bindposes = (UnityEngine.Matrix4x4[])translator.GetObject(L, 2, typeof(UnityEngine.Matrix4x4[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_subMeshCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.subMeshCount = 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_bounds(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Mesh gen_to_be_invoked = (UnityEngine.Mesh)translator.FastGetCSObj(L, 1); + UnityEngine.Bounds gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.bounds = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_MonoBehaviourWrap.cs b/Assets/XLua/Gen/UnityEngine_MonoBehaviourWrap.cs new file mode 100644 index 000000000..e997a7ef4 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_MonoBehaviourWrap.cs @@ -0,0 +1,427 @@ +#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 UnityEngineMonoBehaviourWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.MonoBehaviour); + Utils.BeginObjectRegister(type, L, translator, 0, 7, 1, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsInvoking", _m_IsInvoking); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CancelInvoke", _m_CancelInvoke); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Invoke", _m_Invoke); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InvokeRepeating", _m_InvokeRepeating); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "StartCoroutine", _m_StartCoroutine); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "StopCoroutine", _m_StopCoroutine); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "StopAllCoroutines", _m_StopAllCoroutines); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "useGUILayout", _g_get_useGUILayout); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "useGUILayout", _s_set_useGUILayout); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "print", _m_print_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 UnityEngine.MonoBehaviour(); + 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 UnityEngine.MonoBehaviour constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsInvoking(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MonoBehaviour gen_to_be_invoked = (UnityEngine.MonoBehaviour)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.IsInvoking( ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _methodName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.IsInvoking( _methodName ); + LuaAPI.lua_pushboolean(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 UnityEngine.MonoBehaviour.IsInvoking!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CancelInvoke(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MonoBehaviour gen_to_be_invoked = (UnityEngine.MonoBehaviour)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.CancelInvoke( ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _methodName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.CancelInvoke( _methodName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.MonoBehaviour.CancelInvoke!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Invoke(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MonoBehaviour gen_to_be_invoked = (UnityEngine.MonoBehaviour)translator.FastGetCSObj(L, 1); + + + + { + string _methodName = LuaAPI.lua_tostring(L, 2); + float _time = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.Invoke( _methodName, _time ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_InvokeRepeating(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MonoBehaviour gen_to_be_invoked = (UnityEngine.MonoBehaviour)translator.FastGetCSObj(L, 1); + + + + { + string _methodName = LuaAPI.lua_tostring(L, 2); + float _time = (float)LuaAPI.lua_tonumber(L, 3); + float _repeatRate = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.InvokeRepeating( _methodName, _time, _repeatRate ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_StartCoroutine(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MonoBehaviour gen_to_be_invoked = (UnityEngine.MonoBehaviour)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _methodName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.StartCoroutine( _methodName ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.Collections.IEnumerator _routine = (System.Collections.IEnumerator)translator.GetObject(L, 2, typeof(System.Collections.IEnumerator)); + + var gen_ret = gen_to_be_invoked.StartCoroutine( _routine ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _methodName = LuaAPI.lua_tostring(L, 2); + object _value = translator.GetObject(L, 3, typeof(object)); + + var gen_ret = gen_to_be_invoked.StartCoroutine( _methodName, _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 UnityEngine.MonoBehaviour.StartCoroutine!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_StopCoroutine(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MonoBehaviour gen_to_be_invoked = (UnityEngine.MonoBehaviour)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + System.Collections.IEnumerator _routine = (System.Collections.IEnumerator)translator.GetObject(L, 2, typeof(System.Collections.IEnumerator)); + + gen_to_be_invoked.StopCoroutine( _routine ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Coroutine _routine = (UnityEngine.Coroutine)translator.GetObject(L, 2, typeof(UnityEngine.Coroutine)); + + gen_to_be_invoked.StopCoroutine( _routine ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _methodName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.StopCoroutine( _methodName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.MonoBehaviour.StopCoroutine!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_StopAllCoroutines(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.MonoBehaviour gen_to_be_invoked = (UnityEngine.MonoBehaviour)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.StopAllCoroutines( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_print_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + object _message = translator.GetObject(L, 1, typeof(object)); + + UnityEngine.MonoBehaviour.print( _message ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_useGUILayout(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.MonoBehaviour gen_to_be_invoked = (UnityEngine.MonoBehaviour)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.useGUILayout); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_useGUILayout(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.MonoBehaviour gen_to_be_invoked = (UnityEngine.MonoBehaviour)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.useGUILayout = LuaAPI.lua_toboolean(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_MotionWrap.cs b/Assets/XLua/Gen/UnityEngine_MotionWrap.cs new file mode 100644 index 000000000..238ff41e1 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_MotionWrap.cs @@ -0,0 +1,172 @@ +#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 UnityEngineMotionWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Motion); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 7, 0); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "averageDuration", _g_get_averageDuration); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "averageAngularSpeed", _g_get_averageAngularSpeed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "averageSpeed", _g_get_averageSpeed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "apparentSpeed", _g_get_apparentSpeed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isLooping", _g_get_isLooping); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "legacy", _g_get_legacy); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isHumanMotion", _g_get_isHumanMotion); + + + + 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, "UnityEngine.Motion does not have a constructor!"); + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_averageDuration(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Motion gen_to_be_invoked = (UnityEngine.Motion)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.averageDuration); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_averageAngularSpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Motion gen_to_be_invoked = (UnityEngine.Motion)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.averageAngularSpeed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_averageSpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Motion gen_to_be_invoked = (UnityEngine.Motion)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.averageSpeed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_apparentSpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Motion gen_to_be_invoked = (UnityEngine.Motion)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.apparentSpeed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isLooping(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Motion gen_to_be_invoked = (UnityEngine.Motion)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isLooping); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_legacy(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Motion gen_to_be_invoked = (UnityEngine.Motion)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.legacy); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isHumanMotion(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Motion gen_to_be_invoked = (UnityEngine.Motion)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isHumanMotion); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ObjectWrap.cs b/Assets/XLua/Gen/UnityEngine_ObjectWrap.cs new file mode 100644 index 000000000..225b1017a --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ObjectWrap.cs @@ -0,0 +1,771 @@ +#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 UnityEngineObjectWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Object); + Utils.BeginObjectRegister(type, L, translator, 1, 4, 2, 2); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__eq", __EqMeta); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetInstanceID", _m_GetInstanceID); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashCode", _m_GetHashCode); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Equals", _m_Equals); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "name", _g_get_name); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "hideFlags", _g_get_hideFlags); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "name", _s_set_name); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "hideFlags", _s_set_hideFlags); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 10, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Instantiate", _m_Instantiate_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Destroy", _m_Destroy_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "DestroyImmediate", _m_DestroyImmediate_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FindObjectsOfType", _m_FindObjectsOfType_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FindObjectsByType", _m_FindObjectsByType_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "DontDestroyOnLoad", _m_DontDestroyOnLoad_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FindObjectOfType", _m_FindObjectOfType_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FindFirstObjectByType", _m_FindFirstObjectByType_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FindAnyObjectByType", _m_FindAnyObjectByType_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 UnityEngine.Object(); + 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 UnityEngine.Object constructor!"); + + } + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __EqMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + UnityEngine.Object leftside = (UnityEngine.Object)translator.GetObject(L, 1, typeof(UnityEngine.Object)); + UnityEngine.Object rightside = (UnityEngine.Object)translator.GetObject(L, 2, typeof(UnityEngine.Object)); + + LuaAPI.lua_pushboolean(L, leftside == rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of == operator, need UnityEngine.Object!"); + + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetInstanceID(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Object gen_to_be_invoked = (UnityEngine.Object)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetInstanceID( ); + 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_GetHashCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Object gen_to_be_invoked = (UnityEngine.Object)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetHashCode( ); + 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_Equals(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Object gen_to_be_invoked = (UnityEngine.Object)translator.FastGetCSObj(L, 1); + + + + { + object _other = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.Equals( _other ); + 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_Instantiate_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + UnityEngine.Object _original = (UnityEngine.Object)translator.GetObject(L, 1, typeof(UnityEngine.Object)); + + var gen_ret = UnityEngine.Object.Instantiate( _original ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + UnityEngine.Object _original = (UnityEngine.Object)translator.GetObject(L, 1, typeof(UnityEngine.Object)); + + var gen_ret = UnityEngine.Object.Instantiate( _original ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.Object _original = (UnityEngine.Object)translator.GetObject(L, 1, typeof(UnityEngine.Object)); + UnityEngine.Transform _parent = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + + var gen_ret = UnityEngine.Object.Instantiate( _original, _parent ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.Object _original = (UnityEngine.Object)translator.GetObject(L, 1, typeof(UnityEngine.Object)); + UnityEngine.Transform _parent = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + + var gen_ret = UnityEngine.Object.Instantiate( _original, _parent ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Object _original = (UnityEngine.Object)translator.GetObject(L, 1, typeof(UnityEngine.Object)); + UnityEngine.Transform _parent = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + bool _instantiateInWorldSpace = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = UnityEngine.Object.Instantiate( _original, _parent, _instantiateInWorldSpace ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Object _original = (UnityEngine.Object)translator.GetObject(L, 1, typeof(UnityEngine.Object)); + UnityEngine.Transform _parent = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + bool _worldPositionStays = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = UnityEngine.Object.Instantiate( _original, _parent, _worldPositionStays ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Object _original = (UnityEngine.Object)translator.GetObject(L, 1, typeof(UnityEngine.Object)); + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + UnityEngine.Quaternion _rotation;translator.Get(L, 3, out _rotation); + + var gen_ret = UnityEngine.Object.Instantiate( _original, _position, _rotation ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Object _original = (UnityEngine.Object)translator.GetObject(L, 1, typeof(UnityEngine.Object)); + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + UnityEngine.Quaternion _rotation;translator.Get(L, 3, out _rotation); + + var gen_ret = UnityEngine.Object.Instantiate( _original, _position, _rotation ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Object _original = (UnityEngine.Object)translator.GetObject(L, 1, typeof(UnityEngine.Object)); + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + UnityEngine.Quaternion _rotation;translator.Get(L, 3, out _rotation); + UnityEngine.Transform _parent = (UnityEngine.Transform)translator.GetObject(L, 4, typeof(UnityEngine.Transform)); + + var gen_ret = UnityEngine.Object.Instantiate( _original, _position, _rotation, _parent ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Object _original = (UnityEngine.Object)translator.GetObject(L, 1, typeof(UnityEngine.Object)); + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + UnityEngine.Quaternion _rotation;translator.Get(L, 3, out _rotation); + UnityEngine.Transform _parent = (UnityEngine.Transform)translator.GetObject(L, 4, typeof(UnityEngine.Transform)); + + var gen_ret = UnityEngine.Object.Instantiate( _original, _position, _rotation, _parent ); + 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 UnityEngine.Object.Instantiate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Destroy_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + UnityEngine.Object _obj = (UnityEngine.Object)translator.GetObject(L, 1, typeof(UnityEngine.Object)); + + UnityEngine.Object.Destroy( _obj ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + UnityEngine.Object _obj = (UnityEngine.Object)translator.GetObject(L, 1, typeof(UnityEngine.Object)); + float _t = (float)LuaAPI.lua_tonumber(L, 2); + + UnityEngine.Object.Destroy( _obj, _t ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Object.Destroy!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DestroyImmediate_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + UnityEngine.Object _obj = (UnityEngine.Object)translator.GetObject(L, 1, typeof(UnityEngine.Object)); + + UnityEngine.Object.DestroyImmediate( _obj ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + UnityEngine.Object _obj = (UnityEngine.Object)translator.GetObject(L, 1, typeof(UnityEngine.Object)); + bool _allowDestroyingAssets = LuaAPI.lua_toboolean(L, 2); + + UnityEngine.Object.DestroyImmediate( _obj, _allowDestroyingAssets ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Object.DestroyImmediate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FindObjectsOfType_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + System.Type _type = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + + var gen_ret = UnityEngine.Object.FindObjectsOfType( _type ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + System.Type _type = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + bool _includeInactive = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = UnityEngine.Object.FindObjectsOfType( _type, _includeInactive ); + 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 UnityEngine.Object.FindObjectsOfType!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FindObjectsByType_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + System.Type _type = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + UnityEngine.FindObjectsSortMode _sortMode;translator.Get(L, 2, out _sortMode); + + var gen_ret = UnityEngine.Object.FindObjectsByType( _type, _sortMode ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + System.Type _type = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + UnityEngine.FindObjectsInactive _findObjectsInactive;translator.Get(L, 2, out _findObjectsInactive); + UnityEngine.FindObjectsSortMode _sortMode;translator.Get(L, 3, out _sortMode); + + var gen_ret = UnityEngine.Object.FindObjectsByType( _type, _findObjectsInactive, _sortMode ); + 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 UnityEngine.Object.FindObjectsByType!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DontDestroyOnLoad_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Object _target = (UnityEngine.Object)translator.GetObject(L, 1, typeof(UnityEngine.Object)); + + UnityEngine.Object.DontDestroyOnLoad( _target ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FindObjectOfType_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + System.Type _type = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + + var gen_ret = UnityEngine.Object.FindObjectOfType( _type ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + System.Type _type = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + bool _includeInactive = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = UnityEngine.Object.FindObjectOfType( _type, _includeInactive ); + 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 UnityEngine.Object.FindObjectOfType!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FindFirstObjectByType_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + System.Type _type = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + + var gen_ret = UnityEngine.Object.FindFirstObjectByType( _type ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + System.Type _type = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + UnityEngine.FindObjectsInactive _findObjectsInactive;translator.Get(L, 2, out _findObjectsInactive); + + var gen_ret = UnityEngine.Object.FindFirstObjectByType( _type, _findObjectsInactive ); + 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 UnityEngine.Object.FindFirstObjectByType!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FindAnyObjectByType_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + System.Type _type = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + + var gen_ret = UnityEngine.Object.FindAnyObjectByType( _type ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + System.Type _type = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + UnityEngine.FindObjectsInactive _findObjectsInactive;translator.Get(L, 2, out _findObjectsInactive); + + var gen_ret = UnityEngine.Object.FindAnyObjectByType( _type, _findObjectsInactive ); + 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 UnityEngine.Object.FindAnyObjectByType!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Object gen_to_be_invoked = (UnityEngine.Object)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_name(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Object gen_to_be_invoked = (UnityEngine.Object)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_hideFlags(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Object gen_to_be_invoked = (UnityEngine.Object)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.hideFlags); + } 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); + + UnityEngine.Object gen_to_be_invoked = (UnityEngine.Object)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_hideFlags(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Object gen_to_be_invoked = (UnityEngine.Object)translator.FastGetCSObj(L, 1); + UnityEngine.HideFlags gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.hideFlags = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ParticleSystemRendererWrap.cs b/Assets/XLua/Gen/UnityEngine_ParticleSystemRendererWrap.cs new file mode 100644 index 000000000..a5c461034 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ParticleSystemRendererWrap.cs @@ -0,0 +1,1112 @@ +#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 UnityEngineParticleSystemRendererWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ParticleSystemRenderer); + Utils.BeginObjectRegister(type, L, translator, 0, 8, 23, 21); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetMeshes", _m_GetMeshes); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMeshes", _m_SetMeshes); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetMeshWeightings", _m_GetMeshWeightings); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMeshWeightings", _m_SetMeshWeightings); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "BakeMesh", _m_BakeMesh); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "BakeTrailsMesh", _m_BakeTrailsMesh); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetActiveVertexStreams", _m_SetActiveVertexStreams); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetActiveVertexStreams", _m_GetActiveVertexStreams); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "alignment", _g_get_alignment); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "renderMode", _g_get_renderMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "meshDistribution", _g_get_meshDistribution); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sortMode", _g_get_sortMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lengthScale", _g_get_lengthScale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "velocityScale", _g_get_velocityScale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "cameraVelocityScale", _g_get_cameraVelocityScale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "normalDirection", _g_get_normalDirection); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "shadowBias", _g_get_shadowBias); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sortingFudge", _g_get_sortingFudge); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "minParticleSize", _g_get_minParticleSize); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "maxParticleSize", _g_get_maxParticleSize); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "pivot", _g_get_pivot); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "flip", _g_get_flip); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "maskInteraction", _g_get_maskInteraction); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "trailMaterial", _g_get_trailMaterial); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enableGPUInstancing", _g_get_enableGPUInstancing); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "allowRoll", _g_get_allowRoll); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "freeformStretching", _g_get_freeformStretching); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rotateWithStretchDirection", _g_get_rotateWithStretchDirection); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mesh", _g_get_mesh); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "meshCount", _g_get_meshCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "activeVertexStreamsCount", _g_get_activeVertexStreamsCount); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "alignment", _s_set_alignment); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "renderMode", _s_set_renderMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "meshDistribution", _s_set_meshDistribution); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sortMode", _s_set_sortMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "lengthScale", _s_set_lengthScale); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "velocityScale", _s_set_velocityScale); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "cameraVelocityScale", _s_set_cameraVelocityScale); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "normalDirection", _s_set_normalDirection); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "shadowBias", _s_set_shadowBias); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sortingFudge", _s_set_sortingFudge); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "minParticleSize", _s_set_minParticleSize); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "maxParticleSize", _s_set_maxParticleSize); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "pivot", _s_set_pivot); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "flip", _s_set_flip); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "maskInteraction", _s_set_maskInteraction); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "trailMaterial", _s_set_trailMaterial); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enableGPUInstancing", _s_set_enableGPUInstancing); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "allowRoll", _s_set_allowRoll); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "freeformStretching", _s_set_freeformStretching); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "rotateWithStretchDirection", _s_set_rotateWithStretchDirection); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "mesh", _s_set_mesh); + + + 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 UnityEngine.ParticleSystemRenderer(); + 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 UnityEngine.ParticleSystemRenderer constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetMeshes(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Mesh[] _meshes = (UnityEngine.Mesh[])translator.GetObject(L, 2, typeof(UnityEngine.Mesh[])); + + var gen_ret = gen_to_be_invoked.GetMeshes( _meshes ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMeshes(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Mesh[] _meshes = (UnityEngine.Mesh[])translator.GetObject(L, 2, typeof(UnityEngine.Mesh[])); + + gen_to_be_invoked.SetMeshes( _meshes ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Mesh[] _meshes = (UnityEngine.Mesh[])translator.GetObject(L, 2, typeof(UnityEngine.Mesh[])); + int _size = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetMeshes( _meshes, _size ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystemRenderer.SetMeshes!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetMeshWeightings(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + + + + { + float[] _weightings = (float[])translator.GetObject(L, 2, typeof(float[])); + + var gen_ret = gen_to_be_invoked.GetMeshWeightings( _weightings ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMeshWeightings(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + float[] _weightings = (float[])translator.GetObject(L, 2, typeof(float[])); + + gen_to_be_invoked.SetMeshWeightings( _weightings ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float[] _weightings = (float[])translator.GetObject(L, 2, typeof(float[])); + int _size = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetMeshWeightings( _weightings, _size ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystemRenderer.SetMeshWeightings!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_BakeMesh(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + bool _useTransform = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.BakeMesh( _mesh, _useTransform ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + + gen_to_be_invoked.BakeMesh( _mesh ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 3, typeof(UnityEngine.Camera)); + bool _useTransform = LuaAPI.lua_toboolean(L, 4); + + gen_to_be_invoked.BakeMesh( _mesh, _camera, _useTransform ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 3, typeof(UnityEngine.Camera)); + + gen_to_be_invoked.BakeMesh( _mesh, _camera ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystemRenderer.BakeMesh!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_BakeTrailsMesh(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + bool _useTransform = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.BakeTrailsMesh( _mesh, _useTransform ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + + gen_to_be_invoked.BakeTrailsMesh( _mesh ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 3, typeof(UnityEngine.Camera)); + bool _useTransform = LuaAPI.lua_toboolean(L, 4); + + gen_to_be_invoked.BakeTrailsMesh( _mesh, _camera, _useTransform ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + UnityEngine.Camera _camera = (UnityEngine.Camera)translator.GetObject(L, 3, typeof(UnityEngine.Camera)); + + gen_to_be_invoked.BakeTrailsMesh( _mesh, _camera ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystemRenderer.BakeTrailsMesh!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetActiveVertexStreams(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.List _streams = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.SetActiveVertexStreams( _streams ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetActiveVertexStreams(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.List _streams = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetActiveVertexStreams( _streams ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_alignment(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.alignment); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_renderMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.renderMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_meshDistribution(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.meshDistribution); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sortMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.sortMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lengthScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.lengthScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_velocityScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.velocityScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cameraVelocityScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.cameraVelocityScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_normalDirection(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.normalDirection); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_shadowBias(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.shadowBias); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sortingFudge(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.sortingFudge); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_minParticleSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.minParticleSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxParticleSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.maxParticleSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_pivot(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.pivot); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_flip(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.flip); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maskInteraction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.maskInteraction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_trailMaterial(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.trailMaterial); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enableGPUInstancing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.enableGPUInstancing); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_allowRoll(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.allowRoll); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_freeformStretching(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.freeformStretching); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rotateWithStretchDirection(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.rotateWithStretchDirection); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mesh(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.mesh); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_meshCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.meshCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_activeVertexStreamsCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.activeVertexStreamsCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_alignment(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + UnityEngine.ParticleSystemRenderSpace gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.alignment = 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_renderMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + UnityEngine.ParticleSystemRenderMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.renderMode = 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_meshDistribution(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + UnityEngine.ParticleSystemMeshDistribution gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.meshDistribution = 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_sortMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + UnityEngine.ParticleSystemSortMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.sortMode = 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_lengthScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.lengthScale = (float)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_velocityScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.velocityScale = (float)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_cameraVelocityScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.cameraVelocityScale = (float)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_normalDirection(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.normalDirection = (float)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_shadowBias(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.shadowBias = (float)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_sortingFudge(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.sortingFudge = (float)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_minParticleSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.minParticleSize = (float)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_maxParticleSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.maxParticleSize = (float)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_pivot(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.pivot = 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_flip(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.flip = 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_maskInteraction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + UnityEngine.SpriteMaskInteraction gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.maskInteraction = 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_trailMaterial(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.trailMaterial = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_enableGPUInstancing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.enableGPUInstancing = 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_allowRoll(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.allowRoll = 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_freeformStretching(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.freeformStretching = 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_rotateWithStretchDirection(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.rotateWithStretchDirection = 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_mesh(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystemRenderer gen_to_be_invoked = (UnityEngine.ParticleSystemRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ParticleSystemWrap.cs b/Assets/XLua/Gen/UnityEngine_ParticleSystemWrap.cs new file mode 100644 index 000000000..caeb29360 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ParticleSystemWrap.cs @@ -0,0 +1,1520 @@ +#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 UnityEngineParticleSystemWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ParticleSystem); + Utils.BeginObjectRegister(type, L, translator, 0, 19, 32, 3); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetParticles", _m_SetParticles); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetParticles", _m_GetParticles); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetCustomParticleData", _m_SetCustomParticleData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetCustomParticleData", _m_GetCustomParticleData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPlaybackState", _m_GetPlaybackState); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPlaybackState", _m_SetPlaybackState); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTrails", _m_GetTrails); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTrails", _m_SetTrails); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Simulate", _m_Simulate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Play", _m_Play); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Pause", _m_Pause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Stop", _m_Stop); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsAlive", _m_IsAlive); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Emit", _m_Emit); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TriggerSubEmitter", _m_TriggerSubEmitter); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AllocateAxisOfRotationAttribute", _m_AllocateAxisOfRotationAttribute); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AllocateMeshIndexAttribute", _m_AllocateMeshIndexAttribute); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AllocateCustomDataAttribute", _m_AllocateCustomDataAttribute); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isPlaying", _g_get_isPlaying); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isEmitting", _g_get_isEmitting); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isStopped", _g_get_isStopped); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isPaused", _g_get_isPaused); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "particleCount", _g_get_particleCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "time", _g_get_time); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "randomSeed", _g_get_randomSeed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "useAutoRandomSeed", _g_get_useAutoRandomSeed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "proceduralSimulationSupported", _g_get_proceduralSimulationSupported); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "main", _g_get_main); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "emission", _g_get_emission); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "shape", _g_get_shape); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "velocityOverLifetime", _g_get_velocityOverLifetime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "limitVelocityOverLifetime", _g_get_limitVelocityOverLifetime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "inheritVelocity", _g_get_inheritVelocity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lifetimeByEmitterSpeed", _g_get_lifetimeByEmitterSpeed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "forceOverLifetime", _g_get_forceOverLifetime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "colorOverLifetime", _g_get_colorOverLifetime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "colorBySpeed", _g_get_colorBySpeed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sizeOverLifetime", _g_get_sizeOverLifetime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sizeBySpeed", _g_get_sizeBySpeed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rotationOverLifetime", _g_get_rotationOverLifetime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rotationBySpeed", _g_get_rotationBySpeed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "externalForces", _g_get_externalForces); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "noise", _g_get_noise); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "collision", _g_get_collision); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "trigger", _g_get_trigger); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "subEmitters", _g_get_subEmitters); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "textureSheetAnimation", _g_get_textureSheetAnimation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lights", _g_get_lights); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "trails", _g_get_trails); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "customData", _g_get_customData); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "time", _s_set_time); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "randomSeed", _s_set_randomSeed); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "useAutoRandomSeed", _s_set_useAutoRandomSeed); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 3, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ResetPreMappedBufferMemory", _m_ResetPreMappedBufferMemory_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetMaximumPreMappedBufferCounts", _m_SetMaximumPreMappedBufferCounts_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 UnityEngine.ParticleSystem(); + 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 UnityEngine.ParticleSystem constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetParticles(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.ParticleSystem.Particle[] _particles = (UnityEngine.ParticleSystem.Particle[])translator.GetObject(L, 2, typeof(UnityEngine.ParticleSystem.Particle[])); + + gen_to_be_invoked.SetParticles( _particles ); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + Unity.Collections.NativeArray _particles;translator.Get(L, 2, out _particles); + + gen_to_be_invoked.SetParticles( _particles ); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.ParticleSystem.Particle[] _particles = (UnityEngine.ParticleSystem.Particle[])translator.GetObject(L, 2, typeof(UnityEngine.ParticleSystem.Particle[])); + int _size = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetParticles( _particles, _size ); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + Unity.Collections.NativeArray _particles;translator.Get(L, 2, out _particles); + int _size = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetParticles( _particles, _size ); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.ParticleSystem.Particle[] _particles = (UnityEngine.ParticleSystem.Particle[])translator.GetObject(L, 2, typeof(UnityEngine.ParticleSystem.Particle[])); + int _size = LuaAPI.xlua_tointeger(L, 3); + int _offset = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.SetParticles( _particles, _size, _offset ); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + Unity.Collections.NativeArray _particles;translator.Get(L, 2, out _particles); + int _size = LuaAPI.xlua_tointeger(L, 3); + int _offset = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.SetParticles( _particles, _size, _offset ); + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.SetParticles!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetParticles(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.ParticleSystem.Particle[] _particles = (UnityEngine.ParticleSystem.Particle[])translator.GetObject(L, 2, typeof(UnityEngine.ParticleSystem.Particle[])); + + var gen_ret = gen_to_be_invoked.GetParticles( _particles ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 2; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + Unity.Collections.NativeArray _particles;translator.Get(L, 2, out _particles); + + var gen_ret = gen_to_be_invoked.GetParticles( _particles ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 2; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.ParticleSystem.Particle[] _particles = (UnityEngine.ParticleSystem.Particle[])translator.GetObject(L, 2, typeof(UnityEngine.ParticleSystem.Particle[])); + int _size = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.GetParticles( _particles, _size ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 2; + } + if(gen_param_count == 3&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + Unity.Collections.NativeArray _particles;translator.Get(L, 2, out _particles); + int _size = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.GetParticles( _particles, _size ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 2; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.ParticleSystem.Particle[] _particles = (UnityEngine.ParticleSystem.Particle[])translator.GetObject(L, 2, typeof(UnityEngine.ParticleSystem.Particle[])); + int _size = LuaAPI.xlua_tointeger(L, 3); + int _offset = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.GetParticles( _particles, _size, _offset ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 2; + } + if(gen_param_count == 4&& translator.Assignable>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + Unity.Collections.NativeArray _particles;translator.Get(L, 2, out _particles); + int _size = LuaAPI.xlua_tointeger(L, 3); + int _offset = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.GetParticles( _particles, _size, _offset ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.GetParticles!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetCustomParticleData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.List _customData = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + UnityEngine.ParticleSystemCustomData _streamIndex;translator.Get(L, 3, out _streamIndex); + + gen_to_be_invoked.SetCustomParticleData( _customData, _streamIndex ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetCustomParticleData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.List _customData = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + UnityEngine.ParticleSystemCustomData _streamIndex;translator.Get(L, 3, out _streamIndex); + + var gen_ret = gen_to_be_invoked.GetCustomParticleData( _customData, _streamIndex ); + 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_GetPlaybackState(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetPlaybackState( ); + 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_SetPlaybackState(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.ParticleSystem.PlaybackState _playbackState;translator.Get(L, 2, out _playbackState); + + gen_to_be_invoked.SetPlaybackState( _playbackState ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetTrails(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.GetTrails( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.ParticleSystem.Trails _trailData;translator.Get(L, 2, out _trailData); + + var gen_ret = gen_to_be_invoked.GetTrails( ref _trailData ); + LuaAPI.xlua_pushinteger(L, gen_ret); + translator.Push(L, _trailData); + translator.Update(L, 2, _trailData); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.GetTrails!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTrails(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.ParticleSystem.Trails _trailData;translator.Get(L, 2, out _trailData); + + gen_to_be_invoked.SetTrails( _trailData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Simulate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _t = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.Simulate( _t ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + float _t = (float)LuaAPI.lua_tonumber(L, 2); + bool _withChildren = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.Simulate( _t, _withChildren ); + + + + return 0; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + float _t = (float)LuaAPI.lua_tonumber(L, 2); + bool _withChildren = LuaAPI.lua_toboolean(L, 3); + bool _restart = LuaAPI.lua_toboolean(L, 4); + + gen_to_be_invoked.Simulate( _t, _withChildren, _restart ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)) + { + float _t = (float)LuaAPI.lua_tonumber(L, 2); + bool _withChildren = LuaAPI.lua_toboolean(L, 3); + bool _restart = LuaAPI.lua_toboolean(L, 4); + bool _fixedTimeStep = LuaAPI.lua_toboolean(L, 5); + + gen_to_be_invoked.Simulate( _t, _withChildren, _restart, _fixedTimeStep ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.Simulate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Play(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.Play( ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _withChildren = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.Play( _withChildren ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.Play!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Pause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.Pause( ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _withChildren = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.Pause( _withChildren ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.Pause!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Stop(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.Stop( ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _withChildren = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.Stop( _withChildren ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + bool _withChildren = LuaAPI.lua_toboolean(L, 2); + UnityEngine.ParticleSystemStopBehavior _stopBehavior;translator.Get(L, 3, out _stopBehavior); + + gen_to_be_invoked.Stop( _withChildren, _stopBehavior ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.Stop!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Clear(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.Clear( ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _withChildren = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.Clear( _withChildren ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.Clear!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsAlive(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.IsAlive( ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _withChildren = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = gen_to_be_invoked.IsAlive( _withChildren ); + LuaAPI.lua_pushboolean(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 UnityEngine.ParticleSystem.IsAlive!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Emit(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _count = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.Emit( _count ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.ParticleSystem.EmitParams _emitParams;translator.Get(L, 2, out _emitParams); + int _count = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.Emit( _emitParams, _count ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.Emit!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TriggerSubEmitter(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _subEmitterIndex = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.TriggerSubEmitter( _subEmitterIndex ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _subEmitterIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.ParticleSystem.Particle _particle;translator.Get(L, 3, out _particle); + + gen_to_be_invoked.TriggerSubEmitter( _subEmitterIndex, ref _particle ); + translator.Push(L, _particle); + translator.Update(L, 3, _particle); + + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable>(L, 3)) + { + int _subEmitterIndex = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _particles = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.TriggerSubEmitter( _subEmitterIndex, _particles ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.TriggerSubEmitter!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetPreMappedBufferMemory_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + UnityEngine.ParticleSystem.ResetPreMappedBufferMemory( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMaximumPreMappedBufferCounts_xlua_st_(RealStatePtr L) + { + try { + + + + + { + int _vertexBuffersCount = LuaAPI.xlua_tointeger(L, 1); + int _indexBuffersCount = LuaAPI.xlua_tointeger(L, 2); + + UnityEngine.ParticleSystem.SetMaximumPreMappedBufferCounts( _vertexBuffersCount, _indexBuffersCount ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AllocateAxisOfRotationAttribute(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.AllocateAxisOfRotationAttribute( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AllocateMeshIndexAttribute(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.AllocateMeshIndexAttribute( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AllocateCustomDataAttribute(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.ParticleSystemCustomData _stream;translator.Get(L, 2, out _stream); + + gen_to_be_invoked.AllocateCustomDataAttribute( _stream ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isPlaying(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isPlaying); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isEmitting(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isEmitting); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isStopped(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isStopped); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isPaused(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isPaused); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_particleCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.particleCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_time(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.time); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_randomSeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushuint(L, gen_to_be_invoked.randomSeed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_useAutoRandomSeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.useAutoRandomSeed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_proceduralSimulationSupported(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.proceduralSimulationSupported); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_main(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.main); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_emission(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.emission); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_shape(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.shape); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_velocityOverLifetime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.velocityOverLifetime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_limitVelocityOverLifetime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.limitVelocityOverLifetime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_inheritVelocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.inheritVelocity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lifetimeByEmitterSpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.lifetimeByEmitterSpeed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_forceOverLifetime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.forceOverLifetime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_colorOverLifetime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.colorOverLifetime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_colorBySpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.colorBySpeed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sizeOverLifetime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.sizeOverLifetime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sizeBySpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.sizeBySpeed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rotationOverLifetime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.rotationOverLifetime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rotationBySpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.rotationBySpeed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_externalForces(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.externalForces); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_noise(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.noise); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_collision(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.collision); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_trigger(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.trigger); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_subEmitters(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.subEmitters); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_textureSheetAnimation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.textureSheetAnimation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lights(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.lights); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_trails(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.trails); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_customData(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.customData); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_time(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.time = (float)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_randomSeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.randomSeed = LuaAPI.xlua_touint(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_useAutoRandomSeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem gen_to_be_invoked = (UnityEngine.ParticleSystem)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.useAutoRandomSeed = LuaAPI.lua_toboolean(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ParticleSystem_BurstWrap.cs b/Assets/XLua/Gen/UnityEngine_ParticleSystem_BurstWrap.cs new file mode 100644 index 000000000..f20bef771 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ParticleSystem_BurstWrap.cs @@ -0,0 +1,370 @@ +#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 UnityEngineParticleSystemBurstWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ParticleSystem.Burst); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 7, 7); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "time", _g_get_time); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "count", _g_get_count); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "minCount", _g_get_minCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "maxCount", _g_get_maxCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "cycleCount", _g_get_cycleCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "repeatInterval", _g_get_repeatInterval); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "probability", _g_get_probability); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "time", _s_set_time); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "count", _s_set_count); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "minCount", _s_set_minCount); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "maxCount", _s_set_maxCount); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "cycleCount", _s_set_cycleCount); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "repeatInterval", _s_set_repeatInterval); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "probability", _s_set_probability); + + + 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 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float __time = (float)LuaAPI.lua_tonumber(L, 2); + short __count = (short)LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = new UnityEngine.ParticleSystem.Burst(__time, __count); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 4 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float __time = (float)LuaAPI.lua_tonumber(L, 2); + short __minCount = (short)LuaAPI.xlua_tointeger(L, 3); + short __maxCount = (short)LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = new UnityEngine.ParticleSystem.Burst(__time, __minCount, __maxCount); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 6 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + float __time = (float)LuaAPI.lua_tonumber(L, 2); + short __minCount = (short)LuaAPI.xlua_tointeger(L, 3); + short __maxCount = (short)LuaAPI.xlua_tointeger(L, 4); + int __cycleCount = LuaAPI.xlua_tointeger(L, 5); + float __repeatInterval = (float)LuaAPI.lua_tonumber(L, 6); + + var gen_ret = new UnityEngine.ParticleSystem.Burst(__time, __minCount, __maxCount, __cycleCount, __repeatInterval); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 3 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && translator.Assignable(L, 3)) + { + float __time = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.ParticleSystem.MinMaxCurve __count;translator.Get(L, 3, out __count); + + var gen_ret = new UnityEngine.ParticleSystem.Burst(__time, __count); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 5 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && translator.Assignable(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + float __time = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.ParticleSystem.MinMaxCurve __count;translator.Get(L, 3, out __count); + int __cycleCount = LuaAPI.xlua_tointeger(L, 4); + float __repeatInterval = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = new UnityEngine.ParticleSystem.Burst(__time, __count, __cycleCount, __repeatInterval); + translator.Push(L, gen_ret); + + return 1; + } + + if (LuaAPI.lua_gettop(L) == 1) + { + translator.Push(L, default(UnityEngine.ParticleSystem.Burst)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.Burst constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_time(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Burst gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.time); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_count(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Burst gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.count); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_minCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Burst gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.minCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Burst gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.maxCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cycleCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Burst gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.cycleCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_repeatInterval(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Burst gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.repeatInterval); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_probability(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Burst gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.probability); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_time(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Burst gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.time = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_count(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Burst gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.count = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_minCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Burst gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.minCount = (short)LuaAPI.xlua_tointeger(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_maxCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Burst gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.maxCount = (short)LuaAPI.xlua_tointeger(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_cycleCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Burst gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.cycleCount = LuaAPI.xlua_tointeger(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_repeatInterval(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Burst gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.repeatInterval = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_probability(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Burst gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.probability = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ParticleSystem_CollisionModuleWrap.cs b/Assets/XLua/Gen/UnityEngine_ParticleSystem_CollisionModuleWrap.cs new file mode 100644 index 000000000..134bda984 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ParticleSystem_CollisionModuleWrap.cs @@ -0,0 +1,972 @@ +#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 UnityEngineParticleSystemCollisionModuleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ParticleSystem.CollisionModule); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 23, 22); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddPlane", _m_AddPlane); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemovePlane", _m_RemovePlane); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPlane", _m_SetPlane); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPlane", _m_GetPlane); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enabled", _g_get_enabled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "type", _g_get_type); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mode", _g_get_mode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "dampen", _g_get_dampen); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "dampenMultiplier", _g_get_dampenMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bounce", _g_get_bounce); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bounceMultiplier", _g_get_bounceMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lifetimeLoss", _g_get_lifetimeLoss); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lifetimeLossMultiplier", _g_get_lifetimeLossMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "minKillSpeed", _g_get_minKillSpeed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "maxKillSpeed", _g_get_maxKillSpeed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "collidesWith", _g_get_collidesWith); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enableDynamicColliders", _g_get_enableDynamicColliders); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "maxCollisionShapes", _g_get_maxCollisionShapes); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "quality", _g_get_quality); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "voxelSize", _g_get_voxelSize); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "radiusScale", _g_get_radiusScale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sendCollisionMessages", _g_get_sendCollisionMessages); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "colliderForce", _g_get_colliderForce); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "multiplyColliderForceByCollisionAngle", _g_get_multiplyColliderForceByCollisionAngle); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "multiplyColliderForceByParticleSpeed", _g_get_multiplyColliderForceByParticleSpeed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "multiplyColliderForceByParticleSize", _g_get_multiplyColliderForceByParticleSize); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "planeCount", _g_get_planeCount); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enabled", _s_set_enabled); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "type", _s_set_type); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "mode", _s_set_mode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "dampen", _s_set_dampen); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "dampenMultiplier", _s_set_dampenMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "bounce", _s_set_bounce); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "bounceMultiplier", _s_set_bounceMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "lifetimeLoss", _s_set_lifetimeLoss); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "lifetimeLossMultiplier", _s_set_lifetimeLossMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "minKillSpeed", _s_set_minKillSpeed); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "maxKillSpeed", _s_set_maxKillSpeed); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "collidesWith", _s_set_collidesWith); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enableDynamicColliders", _s_set_enableDynamicColliders); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "maxCollisionShapes", _s_set_maxCollisionShapes); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "quality", _s_set_quality); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "voxelSize", _s_set_voxelSize); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "radiusScale", _s_set_radiusScale); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sendCollisionMessages", _s_set_sendCollisionMessages); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "colliderForce", _s_set_colliderForce); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "multiplyColliderForceByCollisionAngle", _s_set_multiplyColliderForceByCollisionAngle); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "multiplyColliderForceByParticleSpeed", _s_set_multiplyColliderForceByParticleSpeed); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "multiplyColliderForceByParticleSize", _s_set_multiplyColliderForceByParticleSize); + + + 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) + { + translator.Push(L, default(UnityEngine.ParticleSystem.CollisionModule)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.CollisionModule constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddPlane(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.Transform _transform = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + + gen_to_be_invoked.AddPlane( _transform ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemovePlane(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.RemovePlane( _index ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Transform _transform = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + + gen_to_be_invoked.RemovePlane( _transform ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.CollisionModule.RemovePlane!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetPlane(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Transform _transform = (UnityEngine.Transform)translator.GetObject(L, 3, typeof(UnityEngine.Transform)); + + gen_to_be_invoked.SetPlane( _index, _transform ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetPlane(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetPlane( _index ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + 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_type(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.type); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.mode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_dampen(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.dampen); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_dampenMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.dampenMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bounce(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.bounce); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bounceMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.bounceMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lifetimeLoss(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.lifetimeLoss); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lifetimeLossMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.lifetimeLossMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_minKillSpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.minKillSpeed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxKillSpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.maxKillSpeed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_collidesWith(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.collidesWith); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enableDynamicColliders(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.enableDynamicColliders); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxCollisionShapes(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.maxCollisionShapes); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_quality(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.quality); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_voxelSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.voxelSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_radiusScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.radiusScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sendCollisionMessages(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.sendCollisionMessages); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_colliderForce(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.colliderForce); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_multiplyColliderForceByCollisionAngle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.multiplyColliderForceByCollisionAngle); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_multiplyColliderForceByParticleSpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.multiplyColliderForceByParticleSpeed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_multiplyColliderForceByParticleSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.multiplyColliderForceByParticleSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_planeCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.planeCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.enabled = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_type(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemCollisionType gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.type = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_mode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemCollisionMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.mode = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_dampen(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.dampen = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_dampenMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.dampenMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_bounce(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.bounce = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_bounceMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.bounceMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_lifetimeLoss(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.lifetimeLoss = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_lifetimeLossMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.lifetimeLossMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_minKillSpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.minKillSpeed = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_maxKillSpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.maxKillSpeed = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_collidesWith(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.LayerMask gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.collidesWith = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_enableDynamicColliders(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.enableDynamicColliders = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_maxCollisionShapes(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.maxCollisionShapes = LuaAPI.xlua_tointeger(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_quality(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemCollisionQuality gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.quality = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_voxelSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.voxelSize = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_radiusScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.radiusScale = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_sendCollisionMessages(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.sendCollisionMessages = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_colliderForce(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.colliderForce = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_multiplyColliderForceByCollisionAngle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.multiplyColliderForceByCollisionAngle = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_multiplyColliderForceByParticleSpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.multiplyColliderForceByParticleSpeed = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_multiplyColliderForceByParticleSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CollisionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.multiplyColliderForceByParticleSize = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ParticleSystem_ColorBySpeedModuleWrap.cs b/Assets/XLua/Gen/UnityEngine_ParticleSystem_ColorBySpeedModuleWrap.cs new file mode 100644 index 000000000..0c2e648a4 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ParticleSystem_ColorBySpeedModuleWrap.cs @@ -0,0 +1,183 @@ +#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 UnityEngineParticleSystemColorBySpeedModuleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ParticleSystem.ColorBySpeedModule); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 3, 3); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enabled", _g_get_enabled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "color", _g_get_color); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "range", _g_get_range); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enabled", _s_set_enabled); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "color", _s_set_color); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "range", _s_set_range); + + + 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) + { + translator.Push(L, default(UnityEngine.ParticleSystem.ColorBySpeedModule)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.ColorBySpeedModule constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ColorBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + 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_color(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ColorBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.color); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_range(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ColorBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.range); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ColorBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.enabled = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_color(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ColorBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxGradient gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.color = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_range(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ColorBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.range = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ParticleSystem_ColorOverLifetimeModuleWrap.cs b/Assets/XLua/Gen/UnityEngine_ParticleSystem_ColorOverLifetimeModuleWrap.cs new file mode 100644 index 000000000..a275510fb --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ParticleSystem_ColorOverLifetimeModuleWrap.cs @@ -0,0 +1,149 @@ +#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 UnityEngineParticleSystemColorOverLifetimeModuleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ParticleSystem.ColorOverLifetimeModule); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 2); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enabled", _g_get_enabled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "color", _g_get_color); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enabled", _s_set_enabled); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "color", _s_set_color); + + + 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) + { + translator.Push(L, default(UnityEngine.ParticleSystem.ColorOverLifetimeModule)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.ColorOverLifetimeModule constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ColorOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + 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_color(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ColorOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.color); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ColorOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.enabled = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_color(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ColorOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxGradient gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.color = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ParticleSystem_CustomDataModuleWrap.cs b/Assets/XLua/Gen/UnityEngine_ParticleSystem_CustomDataModuleWrap.cs new file mode 100644 index 000000000..82ab935df --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ParticleSystem_CustomDataModuleWrap.cs @@ -0,0 +1,373 @@ +#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 UnityEngineParticleSystemCustomDataModuleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ParticleSystem.CustomDataModule); + Utils.BeginObjectRegister(type, L, translator, 0, 8, 1, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMode", _m_SetMode); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetMode", _m_GetMode); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetVectorComponentCount", _m_SetVectorComponentCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetVectorComponentCount", _m_GetVectorComponentCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetVector", _m_SetVector); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetVector", _m_GetVector); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetColor", _m_SetColor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetColor", _m_GetColor); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enabled", _g_get_enabled); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enabled", _s_set_enabled); + + + 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) + { + translator.Push(L, default(UnityEngine.ParticleSystem.CustomDataModule)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.CustomDataModule constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.CustomDataModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.ParticleSystemCustomData _stream;translator.Get(L, 2, out _stream); + UnityEngine.ParticleSystemCustomDataMode _mode;translator.Get(L, 3, out _mode); + + gen_to_be_invoked.SetMode( _stream, _mode ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetMode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.CustomDataModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.ParticleSystemCustomData _stream;translator.Get(L, 2, out _stream); + + var gen_ret = gen_to_be_invoked.GetMode( _stream ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetVectorComponentCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.CustomDataModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.ParticleSystemCustomData _stream;translator.Get(L, 2, out _stream); + int _count = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetVectorComponentCount( _stream, _count ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetVectorComponentCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.CustomDataModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.ParticleSystemCustomData _stream;translator.Get(L, 2, out _stream); + + var gen_ret = gen_to_be_invoked.GetVectorComponentCount( _stream ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetVector(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.CustomDataModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.ParticleSystemCustomData _stream;translator.Get(L, 2, out _stream); + int _component = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.ParticleSystem.MinMaxCurve _curve;translator.Get(L, 4, out _curve); + + gen_to_be_invoked.SetVector( _stream, _component, _curve ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetVector(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.CustomDataModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.ParticleSystemCustomData _stream;translator.Get(L, 2, out _stream); + int _component = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.GetVector( _stream, _component ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.CustomDataModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.ParticleSystemCustomData _stream;translator.Get(L, 2, out _stream); + UnityEngine.ParticleSystem.MinMaxGradient _gradient;translator.Get(L, 3, out _gradient); + + gen_to_be_invoked.SetColor( _stream, _gradient ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.CustomDataModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.ParticleSystemCustomData _stream;translator.Get(L, 2, out _stream); + + var gen_ret = gen_to_be_invoked.GetColor( _stream ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CustomDataModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + 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 _s_set_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.CustomDataModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.enabled = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ParticleSystem_EmissionModuleWrap.cs b/Assets/XLua/Gen/UnityEngine_ParticleSystem_EmissionModuleWrap.cs new file mode 100644 index 000000000..d59c5313f --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ParticleSystem_EmissionModuleWrap.cs @@ -0,0 +1,426 @@ +#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 UnityEngineParticleSystemEmissionModuleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ParticleSystem.EmissionModule); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 6, 6); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetBursts", _m_SetBursts); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetBursts", _m_GetBursts); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetBurst", _m_SetBurst); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetBurst", _m_GetBurst); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enabled", _g_get_enabled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rateOverTime", _g_get_rateOverTime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rateOverTimeMultiplier", _g_get_rateOverTimeMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rateOverDistance", _g_get_rateOverDistance); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rateOverDistanceMultiplier", _g_get_rateOverDistanceMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "burstCount", _g_get_burstCount); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enabled", _s_set_enabled); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "rateOverTime", _s_set_rateOverTime); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "rateOverTimeMultiplier", _s_set_rateOverTimeMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "rateOverDistance", _s_set_rateOverDistance); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "rateOverDistanceMultiplier", _s_set_rateOverDistanceMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "burstCount", _s_set_burstCount); + + + 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) + { + translator.Push(L, default(UnityEngine.ParticleSystem.EmissionModule)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.EmissionModule constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetBursts(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.EmissionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.ParticleSystem.Burst[] _bursts = (UnityEngine.ParticleSystem.Burst[])translator.GetObject(L, 2, typeof(UnityEngine.ParticleSystem.Burst[])); + + gen_to_be_invoked.SetBursts( _bursts ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.ParticleSystem.Burst[] _bursts = (UnityEngine.ParticleSystem.Burst[])translator.GetObject(L, 2, typeof(UnityEngine.ParticleSystem.Burst[])); + int _size = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetBursts( _bursts, _size ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.EmissionModule.SetBursts!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetBursts(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.EmissionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.ParticleSystem.Burst[] _bursts = (UnityEngine.ParticleSystem.Burst[])translator.GetObject(L, 2, typeof(UnityEngine.ParticleSystem.Burst[])); + + var gen_ret = gen_to_be_invoked.GetBursts( _bursts ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetBurst(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.EmissionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.ParticleSystem.Burst _burst;translator.Get(L, 3, out _burst); + + gen_to_be_invoked.SetBurst( _index, _burst ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetBurst(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.EmissionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetBurst( _index ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmissionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + 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_rateOverTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmissionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.rateOverTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rateOverTimeMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmissionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.rateOverTimeMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rateOverDistance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmissionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.rateOverDistance); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rateOverDistanceMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmissionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.rateOverDistanceMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_burstCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmissionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.burstCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmissionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.enabled = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_rateOverTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmissionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.rateOverTime = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_rateOverTimeMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmissionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.rateOverTimeMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_rateOverDistance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmissionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.rateOverDistance = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_rateOverDistanceMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmissionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.rateOverDistanceMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_burstCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmissionModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.burstCount = LuaAPI.xlua_tointeger(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ParticleSystem_EmitParamsWrap.cs b/Assets/XLua/Gen/UnityEngine_ParticleSystem_EmitParamsWrap.cs new file mode 100644 index 000000000..c30afd47a --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ParticleSystem_EmitParamsWrap.cs @@ -0,0 +1,870 @@ +#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 UnityEngineParticleSystemEmitParamsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ParticleSystem.EmitParams); + Utils.BeginObjectRegister(type, L, translator, 0, 10, 14, 15); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetPosition", _m_ResetPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetVelocity", _m_ResetVelocity); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetAxisOfRotation", _m_ResetAxisOfRotation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetRotation", _m_ResetRotation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetAngularVelocity", _m_ResetAngularVelocity); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetStartSize", _m_ResetStartSize); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetStartColor", _m_ResetStartColor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetRandomSeed", _m_ResetRandomSeed); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetStartLifetime", _m_ResetStartLifetime); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetMeshIndex", _m_ResetMeshIndex); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "particle", _g_get_particle); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "position", _g_get_position); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "applyShapeToPosition", _g_get_applyShapeToPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "velocity", _g_get_velocity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startLifetime", _g_get_startLifetime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startSize", _g_get_startSize); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startSize3D", _g_get_startSize3D); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "axisOfRotation", _g_get_axisOfRotation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rotation", _g_get_rotation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rotation3D", _g_get_rotation3D); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "angularVelocity", _g_get_angularVelocity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "angularVelocity3D", _g_get_angularVelocity3D); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startColor", _g_get_startColor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "randomSeed", _g_get_randomSeed); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "particle", _s_set_particle); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "position", _s_set_position); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "applyShapeToPosition", _s_set_applyShapeToPosition); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "velocity", _s_set_velocity); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startLifetime", _s_set_startLifetime); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startSize", _s_set_startSize); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startSize3D", _s_set_startSize3D); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "axisOfRotation", _s_set_axisOfRotation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "rotation", _s_set_rotation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "rotation3D", _s_set_rotation3D); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "angularVelocity", _s_set_angularVelocity); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "angularVelocity3D", _s_set_angularVelocity3D); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startColor", _s_set_startColor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "randomSeed", _s_set_randomSeed); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "meshIndex", _s_set_meshIndex); + + + 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) + { + translator.Push(L, default(UnityEngine.ParticleSystem.EmitParams)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.EmitParams constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + gen_to_be_invoked.ResetPosition( ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetVelocity(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + gen_to_be_invoked.ResetVelocity( ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetAxisOfRotation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + gen_to_be_invoked.ResetAxisOfRotation( ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetRotation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + gen_to_be_invoked.ResetRotation( ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetAngularVelocity(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + gen_to_be_invoked.ResetAngularVelocity( ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetStartSize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + gen_to_be_invoked.ResetStartSize( ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetStartColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + gen_to_be_invoked.ResetStartColor( ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetRandomSeed(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + gen_to_be_invoked.ResetRandomSeed( ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetStartLifetime(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + gen_to_be_invoked.ResetStartLifetime( ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetMeshIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + gen_to_be_invoked.ResetMeshIndex( ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_particle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.particle); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_position(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.position); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_applyShapeToPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.applyShapeToPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_velocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.velocity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startLifetime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.startLifetime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.startSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startSize3D(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.startSize3D); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_axisOfRotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.axisOfRotation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.rotation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rotation3D(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.rotation3D); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_angularVelocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.angularVelocity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_angularVelocity3D(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.angularVelocity3D); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.startColor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_randomSeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushuint(L, gen_to_be_invoked.randomSeed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_particle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.Particle gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.particle = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_position(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.position = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_applyShapeToPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.applyShapeToPosition = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_velocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.velocity = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startLifetime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.startLifetime = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.startSize = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startSize3D(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.startSize3D = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_axisOfRotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.axisOfRotation = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_rotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.rotation = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_rotation3D(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.rotation3D = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_angularVelocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.angularVelocity = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_angularVelocity3D(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.angularVelocity3D = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Color32 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.startColor = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_randomSeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.randomSeed = LuaAPI.xlua_touint(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_meshIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.EmitParams gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.meshIndex = LuaAPI.xlua_tointeger(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ParticleSystem_ExternalForcesModuleWrap.cs b/Assets/XLua/Gen/UnityEngine_ParticleSystem_ExternalForcesModuleWrap.cs new file mode 100644 index 000000000..0a9b01b8f --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ParticleSystem_ExternalForcesModuleWrap.cs @@ -0,0 +1,469 @@ +#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 UnityEngineParticleSystemExternalForcesModuleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ParticleSystem.ExternalForcesModule); + Utils.BeginObjectRegister(type, L, translator, 0, 6, 6, 5); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsAffectedBy", _m_IsAffectedBy); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddInfluence", _m_AddInfluence); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveInfluence", _m_RemoveInfluence); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveAllInfluences", _m_RemoveAllInfluences); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetInfluence", _m_SetInfluence); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetInfluence", _m_GetInfluence); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enabled", _g_get_enabled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "multiplier", _g_get_multiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "multiplierCurve", _g_get_multiplierCurve); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "influenceFilter", _g_get_influenceFilter); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "influenceMask", _g_get_influenceMask); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "influenceCount", _g_get_influenceCount); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enabled", _s_set_enabled); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "multiplier", _s_set_multiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "multiplierCurve", _s_set_multiplierCurve); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "influenceFilter", _s_set_influenceFilter); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "influenceMask", _s_set_influenceMask); + + + 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) + { + translator.Push(L, default(UnityEngine.ParticleSystem.ExternalForcesModule)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.ExternalForcesModule constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsAffectedBy(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.ExternalForcesModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.ParticleSystemForceField _field = (UnityEngine.ParticleSystemForceField)translator.GetObject(L, 2, typeof(UnityEngine.ParticleSystemForceField)); + + var gen_ret = gen_to_be_invoked.IsAffectedBy( _field ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddInfluence(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.ExternalForcesModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.ParticleSystemForceField _field = (UnityEngine.ParticleSystemForceField)translator.GetObject(L, 2, typeof(UnityEngine.ParticleSystemForceField)); + + gen_to_be_invoked.AddInfluence( _field ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveInfluence(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.ExternalForcesModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.RemoveInfluence( _index ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.ParticleSystemForceField _field = (UnityEngine.ParticleSystemForceField)translator.GetObject(L, 2, typeof(UnityEngine.ParticleSystemForceField)); + + gen_to_be_invoked.RemoveInfluence( _field ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.ExternalForcesModule.RemoveInfluence!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveAllInfluences(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.ExternalForcesModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + gen_to_be_invoked.RemoveAllInfluences( ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetInfluence(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.ExternalForcesModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.ParticleSystemForceField _field = (UnityEngine.ParticleSystemForceField)translator.GetObject(L, 3, typeof(UnityEngine.ParticleSystemForceField)); + + gen_to_be_invoked.SetInfluence( _index, _field ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetInfluence(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.ExternalForcesModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetInfluence( _index ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ExternalForcesModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + 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_multiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ExternalForcesModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.multiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_multiplierCurve(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ExternalForcesModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.multiplierCurve); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_influenceFilter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ExternalForcesModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.influenceFilter); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_influenceMask(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ExternalForcesModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.influenceMask); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_influenceCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ExternalForcesModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.influenceCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ExternalForcesModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.enabled = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_multiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ExternalForcesModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.multiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_multiplierCurve(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ExternalForcesModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.multiplierCurve = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_influenceFilter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ExternalForcesModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemGameObjectFilter gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.influenceFilter = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_influenceMask(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ExternalForcesModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.LayerMask gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.influenceMask = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ParticleSystem_ForceOverLifetimeModuleWrap.cs b/Assets/XLua/Gen/UnityEngine_ParticleSystem_ForceOverLifetimeModuleWrap.cs new file mode 100644 index 000000000..4232b3323 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ParticleSystem_ForceOverLifetimeModuleWrap.cs @@ -0,0 +1,383 @@ +#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 UnityEngineParticleSystemForceOverLifetimeModuleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ParticleSystem.ForceOverLifetimeModule); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 9, 9); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enabled", _g_get_enabled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "x", _g_get_x); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "y", _g_get_y); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "z", _g_get_z); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "xMultiplier", _g_get_xMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "yMultiplier", _g_get_yMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "zMultiplier", _g_get_zMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "space", _g_get_space); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "randomized", _g_get_randomized); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enabled", _s_set_enabled); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "x", _s_set_x); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "y", _s_set_y); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "z", _s_set_z); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "xMultiplier", _s_set_xMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "yMultiplier", _s_set_yMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "zMultiplier", _s_set_zMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "space", _s_set_space); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "randomized", _s_set_randomized); + + + 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) + { + translator.Push(L, default(UnityEngine.ParticleSystem.ForceOverLifetimeModule)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.ForceOverLifetimeModule constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ForceOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + 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_x(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ForceOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.x); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_y(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ForceOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.y); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_z(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ForceOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.z); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_xMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ForceOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.xMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_yMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ForceOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.yMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_zMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ForceOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.zMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_space(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ForceOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.space); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_randomized(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ForceOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.randomized); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ForceOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.enabled = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_x(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ForceOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.x = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_y(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ForceOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.y = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_z(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ForceOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.z = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_xMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ForceOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.xMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_yMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ForceOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.yMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_zMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ForceOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.zMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_space(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ForceOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemSimulationSpace gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.space = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_randomized(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ForceOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.randomized = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ParticleSystem_InheritVelocityModuleWrap.cs b/Assets/XLua/Gen/UnityEngine_ParticleSystem_InheritVelocityModuleWrap.cs new file mode 100644 index 000000000..8df36ccce --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ParticleSystem_InheritVelocityModuleWrap.cs @@ -0,0 +1,216 @@ +#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 UnityEngineParticleSystemInheritVelocityModuleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ParticleSystem.InheritVelocityModule); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 4, 4); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enabled", _g_get_enabled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mode", _g_get_mode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "curve", _g_get_curve); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "curveMultiplier", _g_get_curveMultiplier); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enabled", _s_set_enabled); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "mode", _s_set_mode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "curve", _s_set_curve); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "curveMultiplier", _s_set_curveMultiplier); + + + 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) + { + translator.Push(L, default(UnityEngine.ParticleSystem.InheritVelocityModule)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.InheritVelocityModule constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.InheritVelocityModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + 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_mode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.InheritVelocityModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.mode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_curve(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.InheritVelocityModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.curve); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_curveMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.InheritVelocityModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.curveMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.InheritVelocityModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.enabled = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_mode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.InheritVelocityModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemInheritVelocityMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.mode = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_curve(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.InheritVelocityModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.curve = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_curveMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.InheritVelocityModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.curveMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ParticleSystem_LightsModuleWrap.cs b/Assets/XLua/Gen/UnityEngine_ParticleSystem_LightsModuleWrap.cs new file mode 100644 index 000000000..4f790d6ba --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ParticleSystem_LightsModuleWrap.cs @@ -0,0 +1,480 @@ +#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 UnityEngineParticleSystemLightsModuleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ParticleSystem.LightsModule); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 12, 12); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enabled", _g_get_enabled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ratio", _g_get_ratio); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "useRandomDistribution", _g_get_useRandomDistribution); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "light", _g_get_light); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "useParticleColor", _g_get_useParticleColor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sizeAffectsRange", _g_get_sizeAffectsRange); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "alphaAffectsIntensity", _g_get_alphaAffectsIntensity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "range", _g_get_range); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rangeMultiplier", _g_get_rangeMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "intensity", _g_get_intensity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "intensityMultiplier", _g_get_intensityMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "maxLights", _g_get_maxLights); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enabled", _s_set_enabled); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ratio", _s_set_ratio); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "useRandomDistribution", _s_set_useRandomDistribution); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "light", _s_set_light); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "useParticleColor", _s_set_useParticleColor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sizeAffectsRange", _s_set_sizeAffectsRange); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "alphaAffectsIntensity", _s_set_alphaAffectsIntensity); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "range", _s_set_range); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "rangeMultiplier", _s_set_rangeMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "intensity", _s_set_intensity); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "intensityMultiplier", _s_set_intensityMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "maxLights", _s_set_maxLights); + + + 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) + { + translator.Push(L, default(UnityEngine.ParticleSystem.LightsModule)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.LightsModule constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LightsModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + 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_ratio(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LightsModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.ratio); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_useRandomDistribution(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LightsModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.useRandomDistribution); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_light(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LightsModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.light); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_useParticleColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LightsModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.useParticleColor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sizeAffectsRange(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LightsModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.sizeAffectsRange); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_alphaAffectsIntensity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LightsModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.alphaAffectsIntensity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_range(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LightsModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.range); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rangeMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LightsModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.rangeMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_intensity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LightsModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.intensity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_intensityMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LightsModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.intensityMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxLights(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LightsModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.maxLights); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LightsModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.enabled = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_ratio(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LightsModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.ratio = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_useRandomDistribution(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LightsModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.useRandomDistribution = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_light(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LightsModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.light = (UnityEngine.Light)translator.GetObject(L, 2, typeof(UnityEngine.Light)); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_useParticleColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LightsModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.useParticleColor = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_sizeAffectsRange(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LightsModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.sizeAffectsRange = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_alphaAffectsIntensity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LightsModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.alphaAffectsIntensity = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_range(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LightsModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.range = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_rangeMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LightsModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.rangeMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_intensity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LightsModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.intensity = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_intensityMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LightsModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.intensityMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_maxLights(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LightsModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.maxLights = LuaAPI.xlua_tointeger(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ParticleSystem_LimitVelocityOverLifetimeModuleWrap.cs b/Assets/XLua/Gen/UnityEngine_ParticleSystem_LimitVelocityOverLifetimeModuleWrap.cs new file mode 100644 index 000000000..6a1f69ed4 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ParticleSystem_LimitVelocityOverLifetimeModuleWrap.cs @@ -0,0 +1,616 @@ +#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 UnityEngineParticleSystemLimitVelocityOverLifetimeModuleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 16, 16); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enabled", _g_get_enabled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "limitX", _g_get_limitX); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "limitXMultiplier", _g_get_limitXMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "limitY", _g_get_limitY); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "limitYMultiplier", _g_get_limitYMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "limitZ", _g_get_limitZ); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "limitZMultiplier", _g_get_limitZMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "limit", _g_get_limit); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "limitMultiplier", _g_get_limitMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "dampen", _g_get_dampen); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "separateAxes", _g_get_separateAxes); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "space", _g_get_space); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "drag", _g_get_drag); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "dragMultiplier", _g_get_dragMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "multiplyDragByParticleSize", _g_get_multiplyDragByParticleSize); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "multiplyDragByParticleVelocity", _g_get_multiplyDragByParticleVelocity); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enabled", _s_set_enabled); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "limitX", _s_set_limitX); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "limitXMultiplier", _s_set_limitXMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "limitY", _s_set_limitY); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "limitYMultiplier", _s_set_limitYMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "limitZ", _s_set_limitZ); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "limitZMultiplier", _s_set_limitZMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "limit", _s_set_limit); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "limitMultiplier", _s_set_limitMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "dampen", _s_set_dampen); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "separateAxes", _s_set_separateAxes); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "space", _s_set_space); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "drag", _s_set_drag); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "dragMultiplier", _s_set_dragMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "multiplyDragByParticleSize", _s_set_multiplyDragByParticleSize); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "multiplyDragByParticleVelocity", _s_set_multiplyDragByParticleVelocity); + + + 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) + { + translator.Push(L, default(UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + 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_limitX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.limitX); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_limitXMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.limitXMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_limitY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.limitY); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_limitYMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.limitYMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_limitZ(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.limitZ); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_limitZMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.limitZMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_limit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.limit); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_limitMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.limitMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_dampen(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.dampen); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_separateAxes(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.separateAxes); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_space(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.space); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_drag(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.drag); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_dragMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.dragMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_multiplyDragByParticleSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.multiplyDragByParticleSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_multiplyDragByParticleVelocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.multiplyDragByParticleVelocity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.enabled = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_limitX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.limitX = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_limitXMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.limitXMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_limitY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.limitY = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_limitYMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.limitYMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_limitZ(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.limitZ = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_limitZMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.limitZMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_limit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.limit = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_limitMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.limitMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_dampen(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.dampen = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_separateAxes(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.separateAxes = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_space(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemSimulationSpace gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.space = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_drag(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.drag = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_dragMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.dragMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_multiplyDragByParticleSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.multiplyDragByParticleSize = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_multiplyDragByParticleVelocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.multiplyDragByParticleVelocity = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ParticleSystem_MainModuleWrap.cs b/Assets/XLua/Gen/UnityEngine_ParticleSystem_MainModuleWrap.cs new file mode 100644 index 000000000..81f30ffb2 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ParticleSystem_MainModuleWrap.cs @@ -0,0 +1,1555 @@ +#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 UnityEngineParticleSystemMainModuleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ParticleSystem.MainModule); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 44, 44); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "emitterVelocity", _g_get_emitterVelocity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "duration", _g_get_duration); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "loop", _g_get_loop); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "prewarm", _g_get_prewarm); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startDelay", _g_get_startDelay); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startDelayMultiplier", _g_get_startDelayMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startLifetime", _g_get_startLifetime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startLifetimeMultiplier", _g_get_startLifetimeMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startSpeed", _g_get_startSpeed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startSpeedMultiplier", _g_get_startSpeedMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startSize3D", _g_get_startSize3D); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startSize", _g_get_startSize); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startSizeMultiplier", _g_get_startSizeMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startSizeX", _g_get_startSizeX); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startSizeXMultiplier", _g_get_startSizeXMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startSizeY", _g_get_startSizeY); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startSizeYMultiplier", _g_get_startSizeYMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startSizeZ", _g_get_startSizeZ); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startSizeZMultiplier", _g_get_startSizeZMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startRotation3D", _g_get_startRotation3D); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startRotation", _g_get_startRotation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startRotationMultiplier", _g_get_startRotationMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startRotationX", _g_get_startRotationX); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startRotationXMultiplier", _g_get_startRotationXMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startRotationY", _g_get_startRotationY); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startRotationYMultiplier", _g_get_startRotationYMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startRotationZ", _g_get_startRotationZ); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startRotationZMultiplier", _g_get_startRotationZMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "flipRotation", _g_get_flipRotation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startColor", _g_get_startColor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "gravityModifier", _g_get_gravityModifier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "gravityModifierMultiplier", _g_get_gravityModifierMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "simulationSpace", _g_get_simulationSpace); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "customSimulationSpace", _g_get_customSimulationSpace); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "simulationSpeed", _g_get_simulationSpeed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "useUnscaledTime", _g_get_useUnscaledTime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "scalingMode", _g_get_scalingMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "playOnAwake", _g_get_playOnAwake); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "maxParticles", _g_get_maxParticles); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "emitterVelocityMode", _g_get_emitterVelocityMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "stopAction", _g_get_stopAction); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ringBufferMode", _g_get_ringBufferMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ringBufferLoopRange", _g_get_ringBufferLoopRange); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "cullingMode", _g_get_cullingMode); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "emitterVelocity", _s_set_emitterVelocity); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "duration", _s_set_duration); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "loop", _s_set_loop); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "prewarm", _s_set_prewarm); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startDelay", _s_set_startDelay); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startDelayMultiplier", _s_set_startDelayMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startLifetime", _s_set_startLifetime); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startLifetimeMultiplier", _s_set_startLifetimeMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startSpeed", _s_set_startSpeed); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startSpeedMultiplier", _s_set_startSpeedMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startSize3D", _s_set_startSize3D); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startSize", _s_set_startSize); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startSizeMultiplier", _s_set_startSizeMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startSizeX", _s_set_startSizeX); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startSizeXMultiplier", _s_set_startSizeXMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startSizeY", _s_set_startSizeY); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startSizeYMultiplier", _s_set_startSizeYMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startSizeZ", _s_set_startSizeZ); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startSizeZMultiplier", _s_set_startSizeZMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startRotation3D", _s_set_startRotation3D); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startRotation", _s_set_startRotation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startRotationMultiplier", _s_set_startRotationMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startRotationX", _s_set_startRotationX); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startRotationXMultiplier", _s_set_startRotationXMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startRotationY", _s_set_startRotationY); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startRotationYMultiplier", _s_set_startRotationYMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startRotationZ", _s_set_startRotationZ); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startRotationZMultiplier", _s_set_startRotationZMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "flipRotation", _s_set_flipRotation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startColor", _s_set_startColor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "gravityModifier", _s_set_gravityModifier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "gravityModifierMultiplier", _s_set_gravityModifierMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "simulationSpace", _s_set_simulationSpace); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "customSimulationSpace", _s_set_customSimulationSpace); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "simulationSpeed", _s_set_simulationSpeed); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "useUnscaledTime", _s_set_useUnscaledTime); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "scalingMode", _s_set_scalingMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "playOnAwake", _s_set_playOnAwake); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "maxParticles", _s_set_maxParticles); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "emitterVelocityMode", _s_set_emitterVelocityMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "stopAction", _s_set_stopAction); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ringBufferMode", _s_set_ringBufferMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ringBufferLoopRange", _s_set_ringBufferLoopRange); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "cullingMode", _s_set_cullingMode); + + + 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) + { + translator.Push(L, default(UnityEngine.ParticleSystem.MainModule)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.MainModule constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_emitterVelocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.emitterVelocity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_duration(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.duration); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_loop(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.loop); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_prewarm(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.prewarm); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startDelay(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.startDelay); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startDelayMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.startDelayMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startLifetime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.startLifetime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startLifetimeMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.startLifetimeMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startSpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.startSpeed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startSpeedMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.startSpeedMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startSize3D(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.startSize3D); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.startSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startSizeMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.startSizeMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startSizeX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.startSizeX); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startSizeXMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.startSizeXMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startSizeY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.startSizeY); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startSizeYMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.startSizeYMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startSizeZ(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.startSizeZ); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startSizeZMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.startSizeZMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startRotation3D(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.startRotation3D); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startRotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.startRotation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startRotationMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.startRotationMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startRotationX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.startRotationX); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startRotationXMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.startRotationXMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startRotationY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.startRotationY); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startRotationYMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.startRotationYMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startRotationZ(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.startRotationZ); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startRotationZMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.startRotationZMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_flipRotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.flipRotation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.startColor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_gravityModifier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.gravityModifier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_gravityModifierMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.gravityModifierMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_simulationSpace(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.simulationSpace); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_customSimulationSpace(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.customSimulationSpace); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_simulationSpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.simulationSpeed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_useUnscaledTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.useUnscaledTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_scalingMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.scalingMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_playOnAwake(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.playOnAwake); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxParticles(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.maxParticles); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_emitterVelocityMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.emitterVelocityMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_stopAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.stopAction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ringBufferMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.ringBufferMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ringBufferLoopRange(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.ringBufferLoopRange); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cullingMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.cullingMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_emitterVelocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.emitterVelocity = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_duration(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.duration = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_loop(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.loop = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_prewarm(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.prewarm = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startDelay(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.startDelay = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startDelayMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.startDelayMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startLifetime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.startLifetime = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startLifetimeMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.startLifetimeMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startSpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.startSpeed = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startSpeedMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.startSpeedMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startSize3D(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.startSize3D = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.startSize = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startSizeMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.startSizeMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startSizeX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.startSizeX = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startSizeXMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.startSizeXMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startSizeY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.startSizeY = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startSizeYMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.startSizeYMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startSizeZ(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.startSizeZ = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startSizeZMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.startSizeZMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startRotation3D(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.startRotation3D = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startRotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.startRotation = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startRotationMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.startRotationMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startRotationX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.startRotationX = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startRotationXMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.startRotationXMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startRotationY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.startRotationY = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startRotationYMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.startRotationYMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startRotationZ(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.startRotationZ = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startRotationZMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.startRotationZMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_flipRotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.flipRotation = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxGradient gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.startColor = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_gravityModifier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.gravityModifier = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_gravityModifierMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.gravityModifierMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_simulationSpace(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemSimulationSpace gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.simulationSpace = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_customSimulationSpace(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.customSimulationSpace = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_simulationSpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.simulationSpeed = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_useUnscaledTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.useUnscaledTime = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_scalingMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemScalingMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.scalingMode = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_playOnAwake(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.playOnAwake = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_maxParticles(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.maxParticles = LuaAPI.xlua_tointeger(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_emitterVelocityMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemEmitterVelocityMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.emitterVelocityMode = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_stopAction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemStopAction gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.stopAction = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_ringBufferMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemRingBufferMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.ringBufferMode = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_ringBufferLoopRange(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.ringBufferLoopRange = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_cullingMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MainModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemCullingMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.cullingMode = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ParticleSystem_MinMaxCurveWrap.cs b/Assets/XLua/Gen/UnityEngine_ParticleSystem_MinMaxCurveWrap.cs new file mode 100644 index 000000000..c0a5b4d2d --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ParticleSystem_MinMaxCurveWrap.cs @@ -0,0 +1,437 @@ +#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 UnityEngineParticleSystemMinMaxCurveWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ParticleSystem.MinMaxCurve); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 8, 8); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Evaluate", _m_Evaluate); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mode", _g_get_mode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "curveMultiplier", _g_get_curveMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "curveMax", _g_get_curveMax); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "curveMin", _g_get_curveMin); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "constantMax", _g_get_constantMax); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "constantMin", _g_get_constantMin); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "constant", _g_get_constant); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "curve", _g_get_curve); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "mode", _s_set_mode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "curveMultiplier", _s_set_curveMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "curveMax", _s_set_curveMax); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "curveMin", _s_set_curveMin); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "constantMax", _s_set_constantMax); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "constantMin", _s_set_constantMin); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "constant", _s_set_constant); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "curve", _s_set_curve); + + + 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) == 2 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _constant = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = new UnityEngine.ParticleSystem.MinMaxCurve(_constant); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 3 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && translator.Assignable(L, 3)) + { + float _multiplier = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.AnimationCurve _curve = (UnityEngine.AnimationCurve)translator.GetObject(L, 3, typeof(UnityEngine.AnimationCurve)); + + var gen_ret = new UnityEngine.ParticleSystem.MinMaxCurve(_multiplier, _curve); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 4 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && translator.Assignable(L, 3) && translator.Assignable(L, 4)) + { + float _multiplier = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.AnimationCurve _min = (UnityEngine.AnimationCurve)translator.GetObject(L, 3, typeof(UnityEngine.AnimationCurve)); + UnityEngine.AnimationCurve _max = (UnityEngine.AnimationCurve)translator.GetObject(L, 4, typeof(UnityEngine.AnimationCurve)); + + var gen_ret = new UnityEngine.ParticleSystem.MinMaxCurve(_multiplier, _min, _max); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 3 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _min = (float)LuaAPI.lua_tonumber(L, 2); + float _max = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = new UnityEngine.ParticleSystem.MinMaxCurve(_min, _max); + translator.Push(L, gen_ret); + + return 1; + } + + if (LuaAPI.lua_gettop(L) == 1) + { + translator.Push(L, default(UnityEngine.ParticleSystem.MinMaxCurve)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.MinMaxCurve constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Evaluate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.MinMaxCurve gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _time = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.Evaluate( _time ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _time = (float)LuaAPI.lua_tonumber(L, 2); + float _lerpFactor = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.Evaluate( _time, _lerpFactor ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.MinMaxCurve.Evaluate!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxCurve gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.mode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_curveMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxCurve gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.curveMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_curveMax(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxCurve gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.curveMax); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_curveMin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxCurve gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.curveMin); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_constantMax(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxCurve gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.constantMax); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_constantMin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxCurve gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.constantMin); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_constant(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxCurve gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.constant); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_curve(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxCurve gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.curve); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_mode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxCurve gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemCurveMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.mode = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_curveMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxCurve gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.curveMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_curveMax(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxCurve gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.curveMax = (UnityEngine.AnimationCurve)translator.GetObject(L, 2, typeof(UnityEngine.AnimationCurve)); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_curveMin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxCurve gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.curveMin = (UnityEngine.AnimationCurve)translator.GetObject(L, 2, typeof(UnityEngine.AnimationCurve)); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_constantMax(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxCurve gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.constantMax = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_constantMin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxCurve gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.constantMin = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_constant(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxCurve gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.constant = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_curve(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxCurve gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.curve = (UnityEngine.AnimationCurve)translator.GetObject(L, 2, typeof(UnityEngine.AnimationCurve)); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ParticleSystem_MinMaxGradientWrap.cs b/Assets/XLua/Gen/UnityEngine_ParticleSystem_MinMaxGradientWrap.cs new file mode 100644 index 000000000..c886bbdd2 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ParticleSystem_MinMaxGradientWrap.cs @@ -0,0 +1,405 @@ +#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 UnityEngineParticleSystemMinMaxGradientWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ParticleSystem.MinMaxGradient); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 7, 7); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Evaluate", _m_Evaluate); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mode", _g_get_mode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "gradientMax", _g_get_gradientMax); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "gradientMin", _g_get_gradientMin); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "colorMax", _g_get_colorMax); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "colorMin", _g_get_colorMin); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "color", _g_get_color); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "gradient", _g_get_gradient); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "mode", _s_set_mode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "gradientMax", _s_set_gradientMax); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "gradientMin", _s_set_gradientMin); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "colorMax", _s_set_colorMax); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "colorMin", _s_set_colorMin); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "color", _s_set_color); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "gradient", _s_set_gradient); + + + 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) == 2 && translator.Assignable(L, 2)) + { + UnityEngine.Color _color;translator.Get(L, 2, out _color); + + var gen_ret = new UnityEngine.ParticleSystem.MinMaxGradient(_color); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && translator.Assignable(L, 2)) + { + UnityEngine.Gradient _gradient = (UnityEngine.Gradient)translator.GetObject(L, 2, typeof(UnityEngine.Gradient)); + + var gen_ret = new UnityEngine.ParticleSystem.MinMaxGradient(_gradient); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 3 && translator.Assignable(L, 2) && translator.Assignable(L, 3)) + { + UnityEngine.Color _min;translator.Get(L, 2, out _min); + UnityEngine.Color _max;translator.Get(L, 3, out _max); + + var gen_ret = new UnityEngine.ParticleSystem.MinMaxGradient(_min, _max); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 3 && translator.Assignable(L, 2) && translator.Assignable(L, 3)) + { + UnityEngine.Gradient _min = (UnityEngine.Gradient)translator.GetObject(L, 2, typeof(UnityEngine.Gradient)); + UnityEngine.Gradient _max = (UnityEngine.Gradient)translator.GetObject(L, 3, typeof(UnityEngine.Gradient)); + + var gen_ret = new UnityEngine.ParticleSystem.MinMaxGradient(_min, _max); + translator.Push(L, gen_ret); + + return 1; + } + + if (LuaAPI.lua_gettop(L) == 1) + { + translator.Push(L, default(UnityEngine.ParticleSystem.MinMaxGradient)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.MinMaxGradient constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Evaluate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.MinMaxGradient gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _time = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.Evaluate( _time ); + translator.PushUnityEngineColor(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _time = (float)LuaAPI.lua_tonumber(L, 2); + float _lerpFactor = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.Evaluate( _time, _lerpFactor ); + translator.PushUnityEngineColor(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.MinMaxGradient.Evaluate!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxGradient gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.mode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_gradientMax(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxGradient gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.gradientMax); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_gradientMin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxGradient gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.gradientMin); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_colorMax(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxGradient gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineColor(L, gen_to_be_invoked.colorMax); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_colorMin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxGradient gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineColor(L, gen_to_be_invoked.colorMin); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_color(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxGradient gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineColor(L, gen_to_be_invoked.color); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_gradient(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxGradient gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.gradient); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_mode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxGradient gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemGradientMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.mode = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_gradientMax(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxGradient gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.gradientMax = (UnityEngine.Gradient)translator.GetObject(L, 2, typeof(UnityEngine.Gradient)); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_gradientMin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxGradient gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.gradientMin = (UnityEngine.Gradient)translator.GetObject(L, 2, typeof(UnityEngine.Gradient)); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_colorMax(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxGradient gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Color gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.colorMax = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_colorMin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxGradient gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Color gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.colorMin = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_color(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxGradient gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Color gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.color = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_gradient(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.MinMaxGradient gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.gradient = (UnityEngine.Gradient)translator.GetObject(L, 2, typeof(UnityEngine.Gradient)); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ParticleSystem_NoiseModuleWrap.cs b/Assets/XLua/Gen/UnityEngine_ParticleSystem_NoiseModuleWrap.cs new file mode 100644 index 000000000..612bbaced --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ParticleSystem_NoiseModuleWrap.cs @@ -0,0 +1,1085 @@ +#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 UnityEngineParticleSystemNoiseModuleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ParticleSystem.NoiseModule); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 30, 30); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enabled", _g_get_enabled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "separateAxes", _g_get_separateAxes); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "strength", _g_get_strength); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "strengthMultiplier", _g_get_strengthMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "strengthX", _g_get_strengthX); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "strengthXMultiplier", _g_get_strengthXMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "strengthY", _g_get_strengthY); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "strengthYMultiplier", _g_get_strengthYMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "strengthZ", _g_get_strengthZ); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "strengthZMultiplier", _g_get_strengthZMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "frequency", _g_get_frequency); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "damping", _g_get_damping); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "octaveCount", _g_get_octaveCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "octaveMultiplier", _g_get_octaveMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "octaveScale", _g_get_octaveScale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "quality", _g_get_quality); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "scrollSpeed", _g_get_scrollSpeed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "scrollSpeedMultiplier", _g_get_scrollSpeedMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "remapEnabled", _g_get_remapEnabled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "remap", _g_get_remap); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "remapMultiplier", _g_get_remapMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "remapX", _g_get_remapX); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "remapXMultiplier", _g_get_remapXMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "remapY", _g_get_remapY); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "remapYMultiplier", _g_get_remapYMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "remapZ", _g_get_remapZ); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "remapZMultiplier", _g_get_remapZMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "positionAmount", _g_get_positionAmount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rotationAmount", _g_get_rotationAmount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sizeAmount", _g_get_sizeAmount); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enabled", _s_set_enabled); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "separateAxes", _s_set_separateAxes); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "strength", _s_set_strength); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "strengthMultiplier", _s_set_strengthMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "strengthX", _s_set_strengthX); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "strengthXMultiplier", _s_set_strengthXMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "strengthY", _s_set_strengthY); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "strengthYMultiplier", _s_set_strengthYMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "strengthZ", _s_set_strengthZ); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "strengthZMultiplier", _s_set_strengthZMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "frequency", _s_set_frequency); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "damping", _s_set_damping); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "octaveCount", _s_set_octaveCount); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "octaveMultiplier", _s_set_octaveMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "octaveScale", _s_set_octaveScale); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "quality", _s_set_quality); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "scrollSpeed", _s_set_scrollSpeed); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "scrollSpeedMultiplier", _s_set_scrollSpeedMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "remapEnabled", _s_set_remapEnabled); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "remap", _s_set_remap); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "remapMultiplier", _s_set_remapMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "remapX", _s_set_remapX); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "remapXMultiplier", _s_set_remapXMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "remapY", _s_set_remapY); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "remapYMultiplier", _s_set_remapYMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "remapZ", _s_set_remapZ); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "remapZMultiplier", _s_set_remapZMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "positionAmount", _s_set_positionAmount); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "rotationAmount", _s_set_rotationAmount); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sizeAmount", _s_set_sizeAmount); + + + 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) + { + translator.Push(L, default(UnityEngine.ParticleSystem.NoiseModule)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.NoiseModule constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + 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_separateAxes(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.separateAxes); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_strength(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.strength); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_strengthMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.strengthMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_strengthX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.strengthX); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_strengthXMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.strengthXMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_strengthY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.strengthY); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_strengthYMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.strengthYMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_strengthZ(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.strengthZ); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_strengthZMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.strengthZMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_frequency(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.frequency); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_damping(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.damping); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_octaveCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.octaveCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_octaveMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.octaveMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_octaveScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.octaveScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_quality(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.quality); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_scrollSpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.scrollSpeed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_scrollSpeedMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.scrollSpeedMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_remapEnabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.remapEnabled); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_remap(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.remap); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_remapMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.remapMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_remapX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.remapX); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_remapXMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.remapXMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_remapY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.remapY); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_remapYMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.remapYMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_remapZ(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.remapZ); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_remapZMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.remapZMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_positionAmount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.positionAmount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rotationAmount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.rotationAmount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sizeAmount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.sizeAmount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.enabled = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_separateAxes(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.separateAxes = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_strength(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.strength = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_strengthMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.strengthMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_strengthX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.strengthX = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_strengthXMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.strengthXMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_strengthY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.strengthY = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_strengthYMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.strengthYMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_strengthZ(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.strengthZ = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_strengthZMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.strengthZMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_frequency(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.frequency = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_damping(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.damping = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_octaveCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.octaveCount = LuaAPI.xlua_tointeger(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_octaveMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.octaveMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_octaveScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.octaveScale = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_quality(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemNoiseQuality gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.quality = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_scrollSpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.scrollSpeed = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_scrollSpeedMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.scrollSpeedMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_remapEnabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.remapEnabled = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_remap(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.remap = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_remapMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.remapMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_remapX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.remapX = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_remapXMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.remapXMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_remapY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.remapY = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_remapYMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.remapYMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_remapZ(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.remapZ = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_remapZMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.remapZMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_positionAmount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.positionAmount = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_rotationAmount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.rotationAmount = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_sizeAmount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.NoiseModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.sizeAmount = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ParticleSystem_ParticleWrap.cs b/Assets/XLua/Gen/UnityEngine_ParticleSystem_ParticleWrap.cs new file mode 100644 index 000000000..4305986bf --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ParticleSystem_ParticleWrap.cs @@ -0,0 +1,707 @@ +#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 UnityEngineParticleSystemParticleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ParticleSystem.Particle); + Utils.BeginObjectRegister(type, L, translator, 0, 5, 15, 13); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetCurrentSize", _m_GetCurrentSize); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetCurrentSize3D", _m_GetCurrentSize3D); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetCurrentColor", _m_GetCurrentColor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMeshIndex", _m_SetMeshIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetMeshIndex", _m_GetMeshIndex); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "position", _g_get_position); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "velocity", _g_get_velocity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "animatedVelocity", _g_get_animatedVelocity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "totalVelocity", _g_get_totalVelocity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "remainingLifetime", _g_get_remainingLifetime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startLifetime", _g_get_startLifetime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startColor", _g_get_startColor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "randomSeed", _g_get_randomSeed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "axisOfRotation", _g_get_axisOfRotation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startSize", _g_get_startSize); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startSize3D", _g_get_startSize3D); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rotation", _g_get_rotation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rotation3D", _g_get_rotation3D); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "angularVelocity", _g_get_angularVelocity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "angularVelocity3D", _g_get_angularVelocity3D); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "position", _s_set_position); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "velocity", _s_set_velocity); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "remainingLifetime", _s_set_remainingLifetime); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startLifetime", _s_set_startLifetime); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startColor", _s_set_startColor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "randomSeed", _s_set_randomSeed); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "axisOfRotation", _s_set_axisOfRotation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startSize", _s_set_startSize); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startSize3D", _s_set_startSize3D); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "rotation", _s_set_rotation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "rotation3D", _s_set_rotation3D); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "angularVelocity", _s_set_angularVelocity); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "angularVelocity3D", _s_set_angularVelocity3D); + + + 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) + { + translator.Push(L, default(UnityEngine.ParticleSystem.Particle)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.Particle constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetCurrentSize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.ParticleSystem _system = (UnityEngine.ParticleSystem)translator.GetObject(L, 2, typeof(UnityEngine.ParticleSystem)); + + var gen_ret = gen_to_be_invoked.GetCurrentSize( _system ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetCurrentSize3D(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.ParticleSystem _system = (UnityEngine.ParticleSystem)translator.GetObject(L, 2, typeof(UnityEngine.ParticleSystem)); + + var gen_ret = gen_to_be_invoked.GetCurrentSize3D( _system ); + translator.PushUnityEngineVector3(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetCurrentColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.ParticleSystem _system = (UnityEngine.ParticleSystem)translator.GetObject(L, 2, typeof(UnityEngine.ParticleSystem)); + + var gen_ret = gen_to_be_invoked.GetCurrentColor( _system ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMeshIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetMeshIndex( _index ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetMeshIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.ParticleSystem _system = (UnityEngine.ParticleSystem)translator.GetObject(L, 2, typeof(UnityEngine.ParticleSystem)); + + var gen_ret = gen_to_be_invoked.GetMeshIndex( _system ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_position(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.position); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_velocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.velocity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_animatedVelocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.animatedVelocity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_totalVelocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.totalVelocity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_remainingLifetime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.remainingLifetime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startLifetime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.startLifetime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.startColor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_randomSeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushuint(L, gen_to_be_invoked.randomSeed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_axisOfRotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.axisOfRotation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.startSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startSize3D(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.startSize3D); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.rotation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rotation3D(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.rotation3D); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_angularVelocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.angularVelocity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_angularVelocity3D(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.angularVelocity3D); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_position(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.position = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_velocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.velocity = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_remainingLifetime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.remainingLifetime = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startLifetime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.startLifetime = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Color32 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.startColor = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_randomSeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.randomSeed = LuaAPI.xlua_touint(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_axisOfRotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.axisOfRotation = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.startSize = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startSize3D(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.startSize3D = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_rotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.rotation = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_rotation3D(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.rotation3D = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_angularVelocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.angularVelocity = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_angularVelocity3D(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.Particle gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.angularVelocity3D = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ParticleSystem_RotationBySpeedModuleWrap.cs b/Assets/XLua/Gen/UnityEngine_ParticleSystem_RotationBySpeedModuleWrap.cs new file mode 100644 index 000000000..176bc2738 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ParticleSystem_RotationBySpeedModuleWrap.cs @@ -0,0 +1,383 @@ +#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 UnityEngineParticleSystemRotationBySpeedModuleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ParticleSystem.RotationBySpeedModule); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 9, 9); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enabled", _g_get_enabled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "x", _g_get_x); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "xMultiplier", _g_get_xMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "y", _g_get_y); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "yMultiplier", _g_get_yMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "z", _g_get_z); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "zMultiplier", _g_get_zMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "separateAxes", _g_get_separateAxes); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "range", _g_get_range); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enabled", _s_set_enabled); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "x", _s_set_x); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "xMultiplier", _s_set_xMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "y", _s_set_y); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "yMultiplier", _s_set_yMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "z", _s_set_z); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "zMultiplier", _s_set_zMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "separateAxes", _s_set_separateAxes); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "range", _s_set_range); + + + 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) + { + translator.Push(L, default(UnityEngine.ParticleSystem.RotationBySpeedModule)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.RotationBySpeedModule constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + 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_x(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.x); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_xMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.xMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_y(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.y); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_yMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.yMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_z(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.z); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_zMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.zMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_separateAxes(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.separateAxes); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_range(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.range); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.enabled = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_x(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.x = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_xMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.xMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_y(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.y = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_yMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.yMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_z(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.z = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_zMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.zMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_separateAxes(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.separateAxes = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_range(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.range = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ParticleSystem_RotationOverLifetimeModuleWrap.cs b/Assets/XLua/Gen/UnityEngine_ParticleSystem_RotationOverLifetimeModuleWrap.cs new file mode 100644 index 000000000..f052047c1 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ParticleSystem_RotationOverLifetimeModuleWrap.cs @@ -0,0 +1,349 @@ +#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 UnityEngineParticleSystemRotationOverLifetimeModuleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ParticleSystem.RotationOverLifetimeModule); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 8, 8); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enabled", _g_get_enabled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "x", _g_get_x); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "xMultiplier", _g_get_xMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "y", _g_get_y); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "yMultiplier", _g_get_yMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "z", _g_get_z); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "zMultiplier", _g_get_zMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "separateAxes", _g_get_separateAxes); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enabled", _s_set_enabled); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "x", _s_set_x); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "xMultiplier", _s_set_xMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "y", _s_set_y); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "yMultiplier", _s_set_yMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "z", _s_set_z); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "zMultiplier", _s_set_zMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "separateAxes", _s_set_separateAxes); + + + 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) + { + translator.Push(L, default(UnityEngine.ParticleSystem.RotationOverLifetimeModule)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.RotationOverLifetimeModule constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + 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_x(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.x); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_xMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.xMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_y(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.y); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_yMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.yMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_z(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.z); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_zMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.zMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_separateAxes(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.separateAxes); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.enabled = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_x(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.x = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_xMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.xMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_y(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.y = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_yMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.yMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_z(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.z = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_zMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.zMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_separateAxes(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.RotationOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.separateAxes = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ParticleSystem_ShapeModuleWrap.cs b/Assets/XLua/Gen/UnityEngine_ParticleSystem_ShapeModuleWrap.cs new file mode 100644 index 000000000..864012824 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ParticleSystem_ShapeModuleWrap.cs @@ -0,0 +1,1580 @@ +#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 UnityEngineParticleSystemShapeModuleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ParticleSystem.ShapeModule); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 45, 45); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enabled", _g_get_enabled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "shapeType", _g_get_shapeType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "randomDirectionAmount", _g_get_randomDirectionAmount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sphericalDirectionAmount", _g_get_sphericalDirectionAmount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "randomPositionAmount", _g_get_randomPositionAmount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "alignToDirection", _g_get_alignToDirection); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "radius", _g_get_radius); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "radiusMode", _g_get_radiusMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "radiusSpread", _g_get_radiusSpread); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "radiusSpeed", _g_get_radiusSpeed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "radiusSpeedMultiplier", _g_get_radiusSpeedMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "radiusThickness", _g_get_radiusThickness); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "angle", _g_get_angle); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "length", _g_get_length); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "boxThickness", _g_get_boxThickness); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "meshShapeType", _g_get_meshShapeType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mesh", _g_get_mesh); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "meshRenderer", _g_get_meshRenderer); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "skinnedMeshRenderer", _g_get_skinnedMeshRenderer); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sprite", _g_get_sprite); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "spriteRenderer", _g_get_spriteRenderer); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "useMeshMaterialIndex", _g_get_useMeshMaterialIndex); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "meshMaterialIndex", _g_get_meshMaterialIndex); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "useMeshColors", _g_get_useMeshColors); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "normalOffset", _g_get_normalOffset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "meshSpawnMode", _g_get_meshSpawnMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "meshSpawnSpread", _g_get_meshSpawnSpread); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "meshSpawnSpeed", _g_get_meshSpawnSpeed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "meshSpawnSpeedMultiplier", _g_get_meshSpawnSpeedMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "arc", _g_get_arc); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "arcMode", _g_get_arcMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "arcSpread", _g_get_arcSpread); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "arcSpeed", _g_get_arcSpeed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "arcSpeedMultiplier", _g_get_arcSpeedMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "donutRadius", _g_get_donutRadius); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "position", _g_get_position); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rotation", _g_get_rotation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "scale", _g_get_scale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "texture", _g_get_texture); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "textureClipChannel", _g_get_textureClipChannel); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "textureClipThreshold", _g_get_textureClipThreshold); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "textureColorAffectsParticles", _g_get_textureColorAffectsParticles); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "textureAlphaAffectsParticles", _g_get_textureAlphaAffectsParticles); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "textureBilinearFiltering", _g_get_textureBilinearFiltering); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "textureUVChannel", _g_get_textureUVChannel); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enabled", _s_set_enabled); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "shapeType", _s_set_shapeType); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "randomDirectionAmount", _s_set_randomDirectionAmount); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sphericalDirectionAmount", _s_set_sphericalDirectionAmount); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "randomPositionAmount", _s_set_randomPositionAmount); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "alignToDirection", _s_set_alignToDirection); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "radius", _s_set_radius); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "radiusMode", _s_set_radiusMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "radiusSpread", _s_set_radiusSpread); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "radiusSpeed", _s_set_radiusSpeed); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "radiusSpeedMultiplier", _s_set_radiusSpeedMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "radiusThickness", _s_set_radiusThickness); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "angle", _s_set_angle); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "length", _s_set_length); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "boxThickness", _s_set_boxThickness); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "meshShapeType", _s_set_meshShapeType); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "mesh", _s_set_mesh); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "meshRenderer", _s_set_meshRenderer); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "skinnedMeshRenderer", _s_set_skinnedMeshRenderer); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sprite", _s_set_sprite); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "spriteRenderer", _s_set_spriteRenderer); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "useMeshMaterialIndex", _s_set_useMeshMaterialIndex); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "meshMaterialIndex", _s_set_meshMaterialIndex); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "useMeshColors", _s_set_useMeshColors); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "normalOffset", _s_set_normalOffset); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "meshSpawnMode", _s_set_meshSpawnMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "meshSpawnSpread", _s_set_meshSpawnSpread); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "meshSpawnSpeed", _s_set_meshSpawnSpeed); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "meshSpawnSpeedMultiplier", _s_set_meshSpawnSpeedMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "arc", _s_set_arc); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "arcMode", _s_set_arcMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "arcSpread", _s_set_arcSpread); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "arcSpeed", _s_set_arcSpeed); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "arcSpeedMultiplier", _s_set_arcSpeedMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "donutRadius", _s_set_donutRadius); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "position", _s_set_position); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "rotation", _s_set_rotation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "scale", _s_set_scale); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "texture", _s_set_texture); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "textureClipChannel", _s_set_textureClipChannel); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "textureClipThreshold", _s_set_textureClipThreshold); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "textureColorAffectsParticles", _s_set_textureColorAffectsParticles); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "textureAlphaAffectsParticles", _s_set_textureAlphaAffectsParticles); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "textureBilinearFiltering", _s_set_textureBilinearFiltering); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "textureUVChannel", _s_set_textureUVChannel); + + + 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) + { + translator.Push(L, default(UnityEngine.ParticleSystem.ShapeModule)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.ShapeModule constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + 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_shapeType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.shapeType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_randomDirectionAmount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.randomDirectionAmount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sphericalDirectionAmount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.sphericalDirectionAmount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_randomPositionAmount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.randomPositionAmount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_alignToDirection(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.alignToDirection); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_radius(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.radius); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_radiusMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.radiusMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_radiusSpread(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.radiusSpread); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_radiusSpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.radiusSpeed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_radiusSpeedMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.radiusSpeedMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_radiusThickness(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.radiusThickness); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_angle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.angle); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_length(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.length); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_boxThickness(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.boxThickness); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_meshShapeType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.meshShapeType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mesh(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.mesh); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_meshRenderer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.meshRenderer); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_skinnedMeshRenderer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.skinnedMeshRenderer); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sprite(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.sprite); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_spriteRenderer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.spriteRenderer); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_useMeshMaterialIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.useMeshMaterialIndex); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_meshMaterialIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.meshMaterialIndex); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_useMeshColors(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.useMeshColors); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_normalOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.normalOffset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_meshSpawnMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.meshSpawnMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_meshSpawnSpread(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.meshSpawnSpread); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_meshSpawnSpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.meshSpawnSpeed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_meshSpawnSpeedMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.meshSpawnSpeedMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_arc(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.arc); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_arcMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.arcMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_arcSpread(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.arcSpread); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_arcSpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.arcSpeed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_arcSpeedMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.arcSpeedMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_donutRadius(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.donutRadius); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_position(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.position); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.rotation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_scale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.scale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_texture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.texture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_textureClipChannel(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.textureClipChannel); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_textureClipThreshold(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.textureClipThreshold); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_textureColorAffectsParticles(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.textureColorAffectsParticles); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_textureAlphaAffectsParticles(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.textureAlphaAffectsParticles); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_textureBilinearFiltering(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.textureBilinearFiltering); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_textureUVChannel(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.textureUVChannel); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.enabled = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_shapeType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemShapeType gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.shapeType = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_randomDirectionAmount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.randomDirectionAmount = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_sphericalDirectionAmount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.sphericalDirectionAmount = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_randomPositionAmount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.randomPositionAmount = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_alignToDirection(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.alignToDirection = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_radius(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.radius = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_radiusMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemShapeMultiModeValue gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.radiusMode = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_radiusSpread(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.radiusSpread = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_radiusSpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.radiusSpeed = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_radiusSpeedMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.radiusSpeedMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_radiusThickness(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.radiusThickness = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_angle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.angle = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_length(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.length = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_boxThickness(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.boxThickness = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_meshShapeType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemMeshShapeType gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.meshShapeType = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_mesh(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_meshRenderer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.meshRenderer = (UnityEngine.MeshRenderer)translator.GetObject(L, 2, typeof(UnityEngine.MeshRenderer)); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_skinnedMeshRenderer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.skinnedMeshRenderer = (UnityEngine.SkinnedMeshRenderer)translator.GetObject(L, 2, typeof(UnityEngine.SkinnedMeshRenderer)); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_sprite(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.sprite = (UnityEngine.Sprite)translator.GetObject(L, 2, typeof(UnityEngine.Sprite)); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_spriteRenderer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.spriteRenderer = (UnityEngine.SpriteRenderer)translator.GetObject(L, 2, typeof(UnityEngine.SpriteRenderer)); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_useMeshMaterialIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.useMeshMaterialIndex = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_meshMaterialIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.meshMaterialIndex = LuaAPI.xlua_tointeger(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_useMeshColors(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.useMeshColors = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_normalOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.normalOffset = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_meshSpawnMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemShapeMultiModeValue gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.meshSpawnMode = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_meshSpawnSpread(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.meshSpawnSpread = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_meshSpawnSpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.meshSpawnSpeed = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_meshSpawnSpeedMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.meshSpawnSpeedMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_arc(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.arc = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_arcMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemShapeMultiModeValue gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.arcMode = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_arcSpread(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.arcSpread = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_arcSpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.arcSpeed = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_arcSpeedMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.arcSpeedMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_donutRadius(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.donutRadius = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_position(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.position = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_rotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.rotation = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_scale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.scale = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_texture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.texture = (UnityEngine.Texture2D)translator.GetObject(L, 2, typeof(UnityEngine.Texture2D)); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_textureClipChannel(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemShapeTextureChannel gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.textureClipChannel = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_textureClipThreshold(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.textureClipThreshold = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_textureColorAffectsParticles(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.textureColorAffectsParticles = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_textureAlphaAffectsParticles(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.textureAlphaAffectsParticles = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_textureBilinearFiltering(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.textureBilinearFiltering = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_textureUVChannel(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.ShapeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.textureUVChannel = LuaAPI.xlua_tointeger(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ParticleSystem_SizeBySpeedModuleWrap.cs b/Assets/XLua/Gen/UnityEngine_ParticleSystem_SizeBySpeedModuleWrap.cs new file mode 100644 index 000000000..4e169a784 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ParticleSystem_SizeBySpeedModuleWrap.cs @@ -0,0 +1,450 @@ +#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 UnityEngineParticleSystemSizeBySpeedModuleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ParticleSystem.SizeBySpeedModule); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 11, 11); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enabled", _g_get_enabled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "size", _g_get_size); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sizeMultiplier", _g_get_sizeMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "x", _g_get_x); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "xMultiplier", _g_get_xMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "y", _g_get_y); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "yMultiplier", _g_get_yMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "z", _g_get_z); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "zMultiplier", _g_get_zMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "separateAxes", _g_get_separateAxes); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "range", _g_get_range); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enabled", _s_set_enabled); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "size", _s_set_size); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sizeMultiplier", _s_set_sizeMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "x", _s_set_x); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "xMultiplier", _s_set_xMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "y", _s_set_y); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "yMultiplier", _s_set_yMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "z", _s_set_z); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "zMultiplier", _s_set_zMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "separateAxes", _s_set_separateAxes); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "range", _s_set_range); + + + 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) + { + translator.Push(L, default(UnityEngine.ParticleSystem.SizeBySpeedModule)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.SizeBySpeedModule constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + 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_size(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.size); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sizeMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.sizeMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_x(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.x); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_xMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.xMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_y(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.y); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_yMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.yMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_z(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.z); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_zMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.zMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_separateAxes(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.separateAxes); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_range(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.range); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.enabled = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_size(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.size = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_sizeMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.sizeMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_x(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.x = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_xMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.xMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_y(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.y = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_yMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.yMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_z(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.z = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_zMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.zMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_separateAxes(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.separateAxes = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_range(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeBySpeedModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.range = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ParticleSystem_SizeOverLifetimeModuleWrap.cs b/Assets/XLua/Gen/UnityEngine_ParticleSystem_SizeOverLifetimeModuleWrap.cs new file mode 100644 index 000000000..126657808 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ParticleSystem_SizeOverLifetimeModuleWrap.cs @@ -0,0 +1,416 @@ +#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 UnityEngineParticleSystemSizeOverLifetimeModuleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ParticleSystem.SizeOverLifetimeModule); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 10, 10); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enabled", _g_get_enabled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "size", _g_get_size); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sizeMultiplier", _g_get_sizeMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "x", _g_get_x); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "xMultiplier", _g_get_xMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "y", _g_get_y); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "yMultiplier", _g_get_yMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "z", _g_get_z); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "zMultiplier", _g_get_zMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "separateAxes", _g_get_separateAxes); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enabled", _s_set_enabled); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "size", _s_set_size); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sizeMultiplier", _s_set_sizeMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "x", _s_set_x); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "xMultiplier", _s_set_xMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "y", _s_set_y); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "yMultiplier", _s_set_yMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "z", _s_set_z); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "zMultiplier", _s_set_zMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "separateAxes", _s_set_separateAxes); + + + 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) + { + translator.Push(L, default(UnityEngine.ParticleSystem.SizeOverLifetimeModule)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.SizeOverLifetimeModule constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + 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_size(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.size); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sizeMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.sizeMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_x(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.x); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_xMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.xMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_y(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.y); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_yMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.yMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_z(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.z); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_zMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.zMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_separateAxes(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.separateAxes); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.enabled = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_size(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.size = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_sizeMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.sizeMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_x(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.x = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_xMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.xMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_y(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.y = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_yMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.yMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_z(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.z = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_zMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.zMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_separateAxes(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SizeOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.separateAxes = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ParticleSystem_SubEmittersModuleWrap.cs b/Assets/XLua/Gen/UnityEngine_ParticleSystem_SubEmittersModuleWrap.cs new file mode 100644 index 000000000..49e15fb68 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ParticleSystem_SubEmittersModuleWrap.cs @@ -0,0 +1,485 @@ +#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 UnityEngineParticleSystemSubEmittersModuleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ParticleSystem.SubEmittersModule); + Utils.BeginObjectRegister(type, L, translator, 0, 10, 2, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddSubEmitter", _m_AddSubEmitter); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveSubEmitter", _m_RemoveSubEmitter); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSubEmitterSystem", _m_SetSubEmitterSystem); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSubEmitterType", _m_SetSubEmitterType); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSubEmitterProperties", _m_SetSubEmitterProperties); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSubEmitterEmitProbability", _m_SetSubEmitterEmitProbability); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSubEmitterSystem", _m_GetSubEmitterSystem); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSubEmitterType", _m_GetSubEmitterType); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSubEmitterProperties", _m_GetSubEmitterProperties); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSubEmitterEmitProbability", _m_GetSubEmitterEmitProbability); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enabled", _g_get_enabled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "subEmittersCount", _g_get_subEmittersCount); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enabled", _s_set_enabled); + + + 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) + { + translator.Push(L, default(UnityEngine.ParticleSystem.SubEmittersModule)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.SubEmittersModule constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddSubEmitter(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.SubEmittersModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.ParticleSystem _subEmitter = (UnityEngine.ParticleSystem)translator.GetObject(L, 2, typeof(UnityEngine.ParticleSystem)); + UnityEngine.ParticleSystemSubEmitterType _type;translator.Get(L, 3, out _type); + UnityEngine.ParticleSystemSubEmitterProperties _properties;translator.Get(L, 4, out _properties); + + gen_to_be_invoked.AddSubEmitter( _subEmitter, _type, _properties ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.ParticleSystem _subEmitter = (UnityEngine.ParticleSystem)translator.GetObject(L, 2, typeof(UnityEngine.ParticleSystem)); + UnityEngine.ParticleSystemSubEmitterType _type;translator.Get(L, 3, out _type); + UnityEngine.ParticleSystemSubEmitterProperties _properties;translator.Get(L, 4, out _properties); + float _emitProbability = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.AddSubEmitter( _subEmitter, _type, _properties, _emitProbability ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.SubEmittersModule.AddSubEmitter!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveSubEmitter(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.SubEmittersModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.RemoveSubEmitter( _index ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.ParticleSystem _subEmitter = (UnityEngine.ParticleSystem)translator.GetObject(L, 2, typeof(UnityEngine.ParticleSystem)); + + gen_to_be_invoked.RemoveSubEmitter( _subEmitter ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.SubEmittersModule.RemoveSubEmitter!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSubEmitterSystem(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.SubEmittersModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.ParticleSystem _subEmitter = (UnityEngine.ParticleSystem)translator.GetObject(L, 3, typeof(UnityEngine.ParticleSystem)); + + gen_to_be_invoked.SetSubEmitterSystem( _index, _subEmitter ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSubEmitterType(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.SubEmittersModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.ParticleSystemSubEmitterType _type;translator.Get(L, 3, out _type); + + gen_to_be_invoked.SetSubEmitterType( _index, _type ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSubEmitterProperties(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.SubEmittersModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.ParticleSystemSubEmitterProperties _properties;translator.Get(L, 3, out _properties); + + gen_to_be_invoked.SetSubEmitterProperties( _index, _properties ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSubEmitterEmitProbability(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.SubEmittersModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _emitProbability = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetSubEmitterEmitProbability( _index, _emitProbability ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetSubEmitterSystem(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.SubEmittersModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetSubEmitterSystem( _index ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetSubEmitterType(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.SubEmittersModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetSubEmitterType( _index ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetSubEmitterProperties(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.SubEmittersModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetSubEmitterProperties( _index ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetSubEmitterEmitProbability(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.SubEmittersModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetSubEmitterEmitProbability( _index ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SubEmittersModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + 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_subEmittersCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SubEmittersModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.subEmittersCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.SubEmittersModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.enabled = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ParticleSystem_TextureSheetAnimationModuleWrap.cs b/Assets/XLua/Gen/UnityEngine_ParticleSystem_TextureSheetAnimationModuleWrap.cs new file mode 100644 index 000000000..4a394b708 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ParticleSystem_TextureSheetAnimationModuleWrap.cs @@ -0,0 +1,759 @@ +#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 UnityEngineParticleSystemTextureSheetAnimationModuleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ParticleSystem.TextureSheetAnimationModule); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 17, 16); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddSprite", _m_AddSprite); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveSprite", _m_RemoveSprite); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSprite", _m_SetSprite); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSprite", _m_GetSprite); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enabled", _g_get_enabled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mode", _g_get_mode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "timeMode", _g_get_timeMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fps", _g_get_fps); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "numTilesX", _g_get_numTilesX); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "numTilesY", _g_get_numTilesY); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "animation", _g_get_animation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rowMode", _g_get_rowMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "frameOverTime", _g_get_frameOverTime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "frameOverTimeMultiplier", _g_get_frameOverTimeMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startFrame", _g_get_startFrame); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startFrameMultiplier", _g_get_startFrameMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "cycleCount", _g_get_cycleCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rowIndex", _g_get_rowIndex); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "uvChannelMask", _g_get_uvChannelMask); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "spriteCount", _g_get_spriteCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "speedRange", _g_get_speedRange); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enabled", _s_set_enabled); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "mode", _s_set_mode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "timeMode", _s_set_timeMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fps", _s_set_fps); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "numTilesX", _s_set_numTilesX); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "numTilesY", _s_set_numTilesY); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "animation", _s_set_animation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "rowMode", _s_set_rowMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "frameOverTime", _s_set_frameOverTime); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "frameOverTimeMultiplier", _s_set_frameOverTimeMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startFrame", _s_set_startFrame); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startFrameMultiplier", _s_set_startFrameMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "cycleCount", _s_set_cycleCount); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "rowIndex", _s_set_rowIndex); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "uvChannelMask", _s_set_uvChannelMask); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "speedRange", _s_set_speedRange); + + + 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) + { + translator.Push(L, default(UnityEngine.ParticleSystem.TextureSheetAnimationModule)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.TextureSheetAnimationModule constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddSprite(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.Sprite _sprite = (UnityEngine.Sprite)translator.GetObject(L, 2, typeof(UnityEngine.Sprite)); + + gen_to_be_invoked.AddSprite( _sprite ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveSprite(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.RemoveSprite( _index ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSprite(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Sprite _sprite = (UnityEngine.Sprite)translator.GetObject(L, 3, typeof(UnityEngine.Sprite)); + + gen_to_be_invoked.SetSprite( _index, _sprite ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetSprite(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetSprite( _index ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + 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_mode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.mode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_timeMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.timeMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fps(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.fps); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_numTilesX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.numTilesX); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_numTilesY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.numTilesY); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_animation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.animation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rowMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.rowMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_frameOverTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.frameOverTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_frameOverTimeMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.frameOverTimeMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startFrame(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.startFrame); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startFrameMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.startFrameMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cycleCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.cycleCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rowIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.rowIndex); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_uvChannelMask(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.uvChannelMask); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_spriteCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.spriteCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_speedRange(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.speedRange); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.enabled = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_mode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemAnimationMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.mode = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_timeMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemAnimationTimeMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.timeMode = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_fps(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.fps = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_numTilesX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.numTilesX = LuaAPI.xlua_tointeger(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_numTilesY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.numTilesY = LuaAPI.xlua_tointeger(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_animation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemAnimationType gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.animation = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_rowMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemAnimationRowMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.rowMode = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_frameOverTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.frameOverTime = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_frameOverTimeMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.frameOverTimeMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startFrame(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.startFrame = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startFrameMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.startFrameMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_cycleCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.cycleCount = LuaAPI.xlua_tointeger(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_rowIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.rowIndex = LuaAPI.xlua_tointeger(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_uvChannelMask(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Rendering.UVChannelFlags gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.uvChannelMask = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_speedRange(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TextureSheetAnimationModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.speedRange = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ParticleSystem_TrailModuleWrap.cs b/Assets/XLua/Gen/UnityEngine_ParticleSystem_TrailModuleWrap.cs new file mode 100644 index 000000000..d31928b22 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ParticleSystem_TrailModuleWrap.cs @@ -0,0 +1,781 @@ +#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 UnityEngineParticleSystemTrailModuleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ParticleSystem.TrailModule); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 21, 21); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enabled", _g_get_enabled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mode", _g_get_mode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ratio", _g_get_ratio); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lifetime", _g_get_lifetime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lifetimeMultiplier", _g_get_lifetimeMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "minVertexDistance", _g_get_minVertexDistance); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "textureMode", _g_get_textureMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "worldSpace", _g_get_worldSpace); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "dieWithParticles", _g_get_dieWithParticles); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sizeAffectsWidth", _g_get_sizeAffectsWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sizeAffectsLifetime", _g_get_sizeAffectsLifetime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "inheritParticleColor", _g_get_inheritParticleColor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "colorOverLifetime", _g_get_colorOverLifetime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "widthOverTrail", _g_get_widthOverTrail); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "widthOverTrailMultiplier", _g_get_widthOverTrailMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "colorOverTrail", _g_get_colorOverTrail); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "generateLightingData", _g_get_generateLightingData); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ribbonCount", _g_get_ribbonCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "shadowBias", _g_get_shadowBias); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "splitSubEmitterRibbons", _g_get_splitSubEmitterRibbons); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "attachRibbonsToTransform", _g_get_attachRibbonsToTransform); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enabled", _s_set_enabled); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "mode", _s_set_mode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ratio", _s_set_ratio); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "lifetime", _s_set_lifetime); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "lifetimeMultiplier", _s_set_lifetimeMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "minVertexDistance", _s_set_minVertexDistance); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "textureMode", _s_set_textureMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "worldSpace", _s_set_worldSpace); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "dieWithParticles", _s_set_dieWithParticles); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sizeAffectsWidth", _s_set_sizeAffectsWidth); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sizeAffectsLifetime", _s_set_sizeAffectsLifetime); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "inheritParticleColor", _s_set_inheritParticleColor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "colorOverLifetime", _s_set_colorOverLifetime); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "widthOverTrail", _s_set_widthOverTrail); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "widthOverTrailMultiplier", _s_set_widthOverTrailMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "colorOverTrail", _s_set_colorOverTrail); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "generateLightingData", _s_set_generateLightingData); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ribbonCount", _s_set_ribbonCount); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "shadowBias", _s_set_shadowBias); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "splitSubEmitterRibbons", _s_set_splitSubEmitterRibbons); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "attachRibbonsToTransform", _s_set_attachRibbonsToTransform); + + + 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) + { + translator.Push(L, default(UnityEngine.ParticleSystem.TrailModule)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.TrailModule constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + 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_mode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.mode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ratio(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.ratio); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lifetime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.lifetime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lifetimeMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.lifetimeMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_minVertexDistance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.minVertexDistance); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_textureMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.textureMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_worldSpace(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.worldSpace); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_dieWithParticles(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.dieWithParticles); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sizeAffectsWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.sizeAffectsWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sizeAffectsLifetime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.sizeAffectsLifetime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_inheritParticleColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.inheritParticleColor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_colorOverLifetime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.colorOverLifetime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_widthOverTrail(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.widthOverTrail); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_widthOverTrailMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.widthOverTrailMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_colorOverTrail(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.colorOverTrail); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_generateLightingData(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.generateLightingData); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ribbonCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.ribbonCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_shadowBias(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.shadowBias); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_splitSubEmitterRibbons(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.splitSubEmitterRibbons); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_attachRibbonsToTransform(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.attachRibbonsToTransform); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.enabled = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_mode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemTrailMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.mode = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_ratio(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.ratio = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_lifetime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.lifetime = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_lifetimeMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.lifetimeMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_minVertexDistance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.minVertexDistance = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_textureMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemTrailTextureMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.textureMode = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_worldSpace(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.worldSpace = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_dieWithParticles(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.dieWithParticles = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_sizeAffectsWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.sizeAffectsWidth = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_sizeAffectsLifetime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.sizeAffectsLifetime = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_inheritParticleColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.inheritParticleColor = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_colorOverLifetime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxGradient gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.colorOverLifetime = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_widthOverTrail(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.widthOverTrail = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_widthOverTrailMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.widthOverTrailMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_colorOverTrail(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxGradient gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.colorOverTrail = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_generateLightingData(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.generateLightingData = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_ribbonCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.ribbonCount = LuaAPI.xlua_tointeger(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_shadowBias(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.shadowBias = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_splitSubEmitterRibbons(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.splitSubEmitterRibbons = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_attachRibbonsToTransform(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TrailModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.attachRibbonsToTransform = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ParticleSystem_TriggerModuleWrap.cs b/Assets/XLua/Gen/UnityEngine_ParticleSystem_TriggerModuleWrap.cs new file mode 100644 index 000000000..84ceb6049 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ParticleSystem_TriggerModuleWrap.cs @@ -0,0 +1,475 @@ +#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 UnityEngineParticleSystemTriggerModuleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ParticleSystem.TriggerModule); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 8, 7); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddCollider", _m_AddCollider); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveCollider", _m_RemoveCollider); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetCollider", _m_SetCollider); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetCollider", _m_GetCollider); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enabled", _g_get_enabled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "inside", _g_get_inside); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "outside", _g_get_outside); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enter", _g_get_enter); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "exit", _g_get_exit); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "colliderQueryMode", _g_get_colliderQueryMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "radiusScale", _g_get_radiusScale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "colliderCount", _g_get_colliderCount); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enabled", _s_set_enabled); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "inside", _s_set_inside); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "outside", _s_set_outside); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enter", _s_set_enter); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "exit", _s_set_exit); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "colliderQueryMode", _s_set_colliderQueryMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "radiusScale", _s_set_radiusScale); + + + 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) + { + translator.Push(L, default(UnityEngine.ParticleSystem.TriggerModule)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.TriggerModule constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddCollider(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.TriggerModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.Component _collider = (UnityEngine.Component)translator.GetObject(L, 2, typeof(UnityEngine.Component)); + + gen_to_be_invoked.AddCollider( _collider ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveCollider(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.TriggerModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.RemoveCollider( _index ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Component _collider = (UnityEngine.Component)translator.GetObject(L, 2, typeof(UnityEngine.Component)); + + gen_to_be_invoked.RemoveCollider( _collider ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.TriggerModule.RemoveCollider!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetCollider(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.TriggerModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Component _collider = (UnityEngine.Component)translator.GetObject(L, 3, typeof(UnityEngine.Component)); + + gen_to_be_invoked.SetCollider( _index, _collider ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetCollider(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ParticleSystem.TriggerModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetCollider( _index ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TriggerModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + 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_inside(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TriggerModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.inside); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_outside(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TriggerModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.outside); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TriggerModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.enter); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_exit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TriggerModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.exit); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_colliderQueryMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TriggerModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.colliderQueryMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_radiusScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TriggerModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.radiusScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_colliderCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TriggerModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.colliderCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TriggerModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.enabled = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_inside(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TriggerModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemOverlapAction gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.inside = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_outside(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TriggerModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemOverlapAction gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.outside = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_enter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TriggerModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemOverlapAction gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.enter = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_exit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TriggerModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemOverlapAction gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.exit = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_colliderQueryMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TriggerModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemColliderQueryMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.colliderQueryMode = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_radiusScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.TriggerModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.radiusScale = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ParticleSystem_VelocityOverLifetimeModuleWrap.cs b/Assets/XLua/Gen/UnityEngine_ParticleSystem_VelocityOverLifetimeModuleWrap.cs new file mode 100644 index 000000000..65aea15c9 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ParticleSystem_VelocityOverLifetimeModuleWrap.cs @@ -0,0 +1,886 @@ +#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 UnityEngineParticleSystemVelocityOverLifetimeModuleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ParticleSystem.VelocityOverLifetimeModule); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 24, 24); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enabled", _g_get_enabled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "x", _g_get_x); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "y", _g_get_y); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "z", _g_get_z); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "xMultiplier", _g_get_xMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "yMultiplier", _g_get_yMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "zMultiplier", _g_get_zMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "orbitalX", _g_get_orbitalX); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "orbitalY", _g_get_orbitalY); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "orbitalZ", _g_get_orbitalZ); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "orbitalXMultiplier", _g_get_orbitalXMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "orbitalYMultiplier", _g_get_orbitalYMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "orbitalZMultiplier", _g_get_orbitalZMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "orbitalOffsetX", _g_get_orbitalOffsetX); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "orbitalOffsetY", _g_get_orbitalOffsetY); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "orbitalOffsetZ", _g_get_orbitalOffsetZ); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "orbitalOffsetXMultiplier", _g_get_orbitalOffsetXMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "orbitalOffsetYMultiplier", _g_get_orbitalOffsetYMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "orbitalOffsetZMultiplier", _g_get_orbitalOffsetZMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "radial", _g_get_radial); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "radialMultiplier", _g_get_radialMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "speedModifier", _g_get_speedModifier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "speedModifierMultiplier", _g_get_speedModifierMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "space", _g_get_space); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enabled", _s_set_enabled); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "x", _s_set_x); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "y", _s_set_y); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "z", _s_set_z); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "xMultiplier", _s_set_xMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "yMultiplier", _s_set_yMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "zMultiplier", _s_set_zMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "orbitalX", _s_set_orbitalX); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "orbitalY", _s_set_orbitalY); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "orbitalZ", _s_set_orbitalZ); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "orbitalXMultiplier", _s_set_orbitalXMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "orbitalYMultiplier", _s_set_orbitalYMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "orbitalZMultiplier", _s_set_orbitalZMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "orbitalOffsetX", _s_set_orbitalOffsetX); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "orbitalOffsetY", _s_set_orbitalOffsetY); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "orbitalOffsetZ", _s_set_orbitalOffsetZ); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "orbitalOffsetXMultiplier", _s_set_orbitalOffsetXMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "orbitalOffsetYMultiplier", _s_set_orbitalOffsetYMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "orbitalOffsetZMultiplier", _s_set_orbitalOffsetZMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "radial", _s_set_radial); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "radialMultiplier", _s_set_radialMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "speedModifier", _s_set_speedModifier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "speedModifierMultiplier", _s_set_speedModifierMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "space", _s_set_space); + + + 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) + { + translator.Push(L, default(UnityEngine.ParticleSystem.VelocityOverLifetimeModule)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ParticleSystem.VelocityOverLifetimeModule constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + 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_x(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.x); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_y(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.y); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_z(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.z); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_xMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.xMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_yMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.yMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_zMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.zMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_orbitalX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.orbitalX); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_orbitalY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.orbitalY); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_orbitalZ(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.orbitalZ); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_orbitalXMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.orbitalXMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_orbitalYMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.orbitalYMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_orbitalZMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.orbitalZMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_orbitalOffsetX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.orbitalOffsetX); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_orbitalOffsetY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.orbitalOffsetY); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_orbitalOffsetZ(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.orbitalOffsetZ); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_orbitalOffsetXMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.orbitalOffsetXMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_orbitalOffsetYMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.orbitalOffsetYMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_orbitalOffsetZMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.orbitalOffsetZMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_radial(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.radial); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_radialMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.radialMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_speedModifier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.speedModifier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_speedModifierMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.speedModifierMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_space(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.space); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_enabled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.enabled = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_x(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.x = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_y(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.y = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_z(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.z = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_xMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.xMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_yMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.yMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_zMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.zMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_orbitalX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.orbitalX = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_orbitalY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.orbitalY = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_orbitalZ(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.orbitalZ = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_orbitalXMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.orbitalXMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_orbitalYMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.orbitalYMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_orbitalZMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.orbitalZMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_orbitalOffsetX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.orbitalOffsetX = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_orbitalOffsetY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.orbitalOffsetY = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_orbitalOffsetZ(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.orbitalOffsetZ = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_orbitalOffsetXMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.orbitalOffsetXMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_orbitalOffsetYMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.orbitalOffsetYMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_orbitalOffsetZMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.orbitalOffsetZMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_radial(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.radial = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_radialMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.radialMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_speedModifier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystem.MinMaxCurve gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.speedModifier = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_speedModifierMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.speedModifierMultiplier = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_space(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ParticleSystem.VelocityOverLifetimeModule gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.ParticleSystemSimulationSpace gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.space = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_PhysicMaterialWrap.cs b/Assets/XLua/Gen/UnityEngine_PhysicMaterialWrap.cs new file mode 100644 index 000000000..d2ab2dd22 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_PhysicMaterialWrap.cs @@ -0,0 +1,250 @@ +#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 UnityEnginePhysicMaterialWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.PhysicMaterial); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 5, 5); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bounciness", _g_get_bounciness); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "dynamicFriction", _g_get_dynamicFriction); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "staticFriction", _g_get_staticFriction); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "frictionCombine", _g_get_frictionCombine); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bounceCombine", _g_get_bounceCombine); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "bounciness", _s_set_bounciness); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "dynamicFriction", _s_set_dynamicFriction); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "staticFriction", _s_set_staticFriction); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "frictionCombine", _s_set_frictionCombine); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "bounceCombine", _s_set_bounceCombine); + + + 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 UnityEngine.PhysicMaterial(); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = new UnityEngine.PhysicMaterial(_name); + 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 UnityEngine.PhysicMaterial constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bounciness(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.PhysicMaterial gen_to_be_invoked = (UnityEngine.PhysicMaterial)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.bounciness); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_dynamicFriction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.PhysicMaterial gen_to_be_invoked = (UnityEngine.PhysicMaterial)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.dynamicFriction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_staticFriction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.PhysicMaterial gen_to_be_invoked = (UnityEngine.PhysicMaterial)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.staticFriction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_frictionCombine(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.PhysicMaterial gen_to_be_invoked = (UnityEngine.PhysicMaterial)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.frictionCombine); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bounceCombine(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.PhysicMaterial gen_to_be_invoked = (UnityEngine.PhysicMaterial)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.bounceCombine); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_bounciness(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.PhysicMaterial gen_to_be_invoked = (UnityEngine.PhysicMaterial)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.bounciness = (float)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_dynamicFriction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.PhysicMaterial gen_to_be_invoked = (UnityEngine.PhysicMaterial)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.dynamicFriction = (float)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_staticFriction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.PhysicMaterial gen_to_be_invoked = (UnityEngine.PhysicMaterial)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.staticFriction = (float)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_frictionCombine(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.PhysicMaterial gen_to_be_invoked = (UnityEngine.PhysicMaterial)translator.FastGetCSObj(L, 1); + UnityEngine.PhysicMaterialCombine gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.frictionCombine = 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_bounceCombine(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.PhysicMaterial gen_to_be_invoked = (UnityEngine.PhysicMaterial)translator.FastGetCSObj(L, 1); + UnityEngine.PhysicMaterialCombine gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.bounceCombine = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_PhysicsWrap.cs b/Assets/XLua/Gen/UnityEngine_PhysicsWrap.cs new file mode 100644 index 000000000..cedbfd849 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_PhysicsWrap.cs @@ -0,0 +1,3381 @@ +#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 UnityEnginePhysicsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Physics); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 38, 19, 18); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IgnoreCollision", _m_IgnoreCollision_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IgnoreLayerCollision", _m_IgnoreLayerCollision_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetIgnoreLayerCollision", _m_GetIgnoreLayerCollision_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetIgnoreCollision", _m_GetIgnoreCollision_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Raycast", _m_Raycast_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Linecast", _m_Linecast_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CapsuleCast", _m_CapsuleCast_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SphereCast", _m_SphereCast_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "BoxCast", _m_BoxCast_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RaycastAll", _m_RaycastAll_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RaycastNonAlloc", _m_RaycastNonAlloc_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CapsuleCastAll", _m_CapsuleCastAll_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SphereCastAll", _m_SphereCastAll_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "OverlapCapsule", _m_OverlapCapsule_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "OverlapSphere", _m_OverlapSphere_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Simulate", _m_Simulate_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SyncTransforms", _m_SyncTransforms_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ComputePenetration", _m_ComputePenetration_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ClosestPoint", _m_ClosestPoint_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "OverlapSphereNonAlloc", _m_OverlapSphereNonAlloc_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CheckSphere", _m_CheckSphere_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CapsuleCastNonAlloc", _m_CapsuleCastNonAlloc_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SphereCastNonAlloc", _m_SphereCastNonAlloc_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CheckCapsule", _m_CheckCapsule_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CheckBox", _m_CheckBox_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "OverlapBox", _m_OverlapBox_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "OverlapBoxNonAlloc", _m_OverlapBoxNonAlloc_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "BoxCastNonAlloc", _m_BoxCastNonAlloc_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "BoxCastAll", _m_BoxCastAll_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "OverlapCapsuleNonAlloc", _m_OverlapCapsuleNonAlloc_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RebuildBroadphaseRegions", _m_RebuildBroadphaseRegions_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "BakeMesh", _m_BakeMesh_xlua_st_); + + Utils.RegisterFunc(L, Utils.CLS_IDX, "ContactModifyEvent", _e_ContactModifyEvent); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ContactModifyEventCCD", _e_ContactModifyEventCCD); + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IgnoreRaycastLayer", UnityEngine.Physics.IgnoreRaycastLayer); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DefaultRaycastLayers", UnityEngine.Physics.DefaultRaycastLayers); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AllLayers", UnityEngine.Physics.AllLayers); + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "gravity", _g_get_gravity); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "defaultContactOffset", _g_get_defaultContactOffset); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "sleepThreshold", _g_get_sleepThreshold); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "queriesHitTriggers", _g_get_queriesHitTriggers); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "queriesHitBackfaces", _g_get_queriesHitBackfaces); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "bounceThreshold", _g_get_bounceThreshold); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "defaultMaxDepenetrationVelocity", _g_get_defaultMaxDepenetrationVelocity); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "defaultSolverIterations", _g_get_defaultSolverIterations); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "defaultSolverVelocityIterations", _g_get_defaultSolverVelocityIterations); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "defaultMaxAngularSpeed", _g_get_defaultMaxAngularSpeed); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "improvedPatchFriction", _g_get_improvedPatchFriction); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "defaultPhysicsScene", _g_get_defaultPhysicsScene); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "autoSimulation", _g_get_autoSimulation); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "autoSyncTransforms", _g_get_autoSyncTransforms); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "reuseCollisionCallbacks", _g_get_reuseCollisionCallbacks); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "interCollisionDistance", _g_get_interCollisionDistance); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "interCollisionStiffness", _g_get_interCollisionStiffness); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "interCollisionSettingsToggle", _g_get_interCollisionSettingsToggle); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "clothGravity", _g_get_clothGravity); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "gravity", _s_set_gravity); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "defaultContactOffset", _s_set_defaultContactOffset); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "sleepThreshold", _s_set_sleepThreshold); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "queriesHitTriggers", _s_set_queriesHitTriggers); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "queriesHitBackfaces", _s_set_queriesHitBackfaces); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "bounceThreshold", _s_set_bounceThreshold); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "defaultMaxDepenetrationVelocity", _s_set_defaultMaxDepenetrationVelocity); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "defaultSolverIterations", _s_set_defaultSolverIterations); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "defaultSolverVelocityIterations", _s_set_defaultSolverVelocityIterations); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "defaultMaxAngularSpeed", _s_set_defaultMaxAngularSpeed); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "improvedPatchFriction", _s_set_improvedPatchFriction); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "autoSimulation", _s_set_autoSimulation); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "autoSyncTransforms", _s_set_autoSyncTransforms); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "reuseCollisionCallbacks", _s_set_reuseCollisionCallbacks); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "interCollisionDistance", _s_set_interCollisionDistance); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "interCollisionStiffness", _s_set_interCollisionStiffness); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "interCollisionSettingsToggle", _s_set_interCollisionSettingsToggle); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "clothGravity", _s_set_clothGravity); + + + 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 UnityEngine.Physics(); + 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 UnityEngine.Physics constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IgnoreCollision_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.Collider _collider1 = (UnityEngine.Collider)translator.GetObject(L, 1, typeof(UnityEngine.Collider)); + UnityEngine.Collider _collider2 = (UnityEngine.Collider)translator.GetObject(L, 2, typeof(UnityEngine.Collider)); + + UnityEngine.Physics.IgnoreCollision( _collider1, _collider2 ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Collider _collider1 = (UnityEngine.Collider)translator.GetObject(L, 1, typeof(UnityEngine.Collider)); + UnityEngine.Collider _collider2 = (UnityEngine.Collider)translator.GetObject(L, 2, typeof(UnityEngine.Collider)); + bool _ignore = LuaAPI.lua_toboolean(L, 3); + + UnityEngine.Physics.IgnoreCollision( _collider1, _collider2, _ignore ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Physics.IgnoreCollision!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IgnoreLayerCollision_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _layer1 = LuaAPI.xlua_tointeger(L, 1); + int _layer2 = LuaAPI.xlua_tointeger(L, 2); + + UnityEngine.Physics.IgnoreLayerCollision( _layer1, _layer2 ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + int _layer1 = LuaAPI.xlua_tointeger(L, 1); + int _layer2 = LuaAPI.xlua_tointeger(L, 2); + bool _ignore = LuaAPI.lua_toboolean(L, 3); + + UnityEngine.Physics.IgnoreLayerCollision( _layer1, _layer2, _ignore ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Physics.IgnoreLayerCollision!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetIgnoreLayerCollision_xlua_st_(RealStatePtr L) + { + try { + + + + + { + int _layer1 = LuaAPI.xlua_tointeger(L, 1); + int _layer2 = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = UnityEngine.Physics.GetIgnoreLayerCollision( _layer1, _layer2 ); + 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_GetIgnoreCollision_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Collider _collider1 = (UnityEngine.Collider)translator.GetObject(L, 1, typeof(UnityEngine.Collider)); + UnityEngine.Collider _collider2 = (UnityEngine.Collider)translator.GetObject(L, 2, typeof(UnityEngine.Collider)); + + var gen_ret = UnityEngine.Physics.GetIgnoreCollision( _collider1, _collider2 ); + 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_Raycast_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + + var gen_ret = UnityEngine.Physics.Raycast( _ray ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = UnityEngine.Physics.Raycast( _ray, _maxDistance ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + UnityEngine.RaycastHit _hitInfo; + + var gen_ret = UnityEngine.Physics.Raycast( _ray, out _hitInfo ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 2); + int _layerMask = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = UnityEngine.Physics.Raycast( _ray, _maxDistance, _layerMask ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + UnityEngine.RaycastHit _hitInfo; + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = UnityEngine.Physics.Raycast( _ray, out _hitInfo, _maxDistance ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + UnityEngine.RaycastHit _hitInfo; + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 2); + int _layerMask = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = UnityEngine.Physics.Raycast( _ray, out _hitInfo, _maxDistance, _layerMask ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _origin;translator.Get(L, 1, out _origin); + UnityEngine.Vector3 _direction;translator.Get(L, 2, out _direction); + + var gen_ret = UnityEngine.Physics.Raycast( _origin, _direction ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _origin;translator.Get(L, 1, out _origin); + UnityEngine.Vector3 _direction;translator.Get(L, 2, out _direction); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Physics.Raycast( _origin, _direction, _maxDistance ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _origin;translator.Get(L, 1, out _origin); + UnityEngine.Vector3 _direction;translator.Get(L, 2, out _direction); + UnityEngine.RaycastHit _hitInfo; + + var gen_ret = UnityEngine.Physics.Raycast( _origin, _direction, out _hitInfo ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3 _origin;translator.Get(L, 1, out _origin); + UnityEngine.Vector3 _direction;translator.Get(L, 2, out _direction); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 3); + int _layerMask = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = UnityEngine.Physics.Raycast( _origin, _direction, _maxDistance, _layerMask ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _origin;translator.Get(L, 1, out _origin); + UnityEngine.Vector3 _direction;translator.Get(L, 2, out _direction); + UnityEngine.RaycastHit _hitInfo; + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Physics.Raycast( _origin, _direction, out _hitInfo, _maxDistance ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 2); + int _layerMask = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 4, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.Raycast( _ray, _maxDistance, _layerMask, _queryTriggerInteraction ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3 _origin;translator.Get(L, 1, out _origin); + UnityEngine.Vector3 _direction;translator.Get(L, 2, out _direction); + UnityEngine.RaycastHit _hitInfo; + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 3); + int _layerMask = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = UnityEngine.Physics.Raycast( _origin, _direction, out _hitInfo, _maxDistance, _layerMask ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + UnityEngine.RaycastHit _hitInfo; + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 2); + int _layerMask = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 4, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.Raycast( _ray, out _hitInfo, _maxDistance, _layerMask, _queryTriggerInteraction ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + UnityEngine.Vector3 _origin;translator.Get(L, 1, out _origin); + UnityEngine.Vector3 _direction;translator.Get(L, 2, out _direction); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 3); + int _layerMask = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 5, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.Raycast( _origin, _direction, _maxDistance, _layerMask, _queryTriggerInteraction ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + UnityEngine.Vector3 _origin;translator.Get(L, 1, out _origin); + UnityEngine.Vector3 _direction;translator.Get(L, 2, out _direction); + UnityEngine.RaycastHit _hitInfo; + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 3); + int _layerMask = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 5, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.Raycast( _origin, _direction, out _hitInfo, _maxDistance, _layerMask, _queryTriggerInteraction ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Physics.Raycast!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Linecast_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _start;translator.Get(L, 1, out _start); + UnityEngine.Vector3 _end;translator.Get(L, 2, out _end); + + var gen_ret = UnityEngine.Physics.Linecast( _start, _end ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _start;translator.Get(L, 1, out _start); + UnityEngine.Vector3 _end;translator.Get(L, 2, out _end); + int _layerMask = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = UnityEngine.Physics.Linecast( _start, _end, _layerMask ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _start;translator.Get(L, 1, out _start); + UnityEngine.Vector3 _end;translator.Get(L, 2, out _end); + UnityEngine.RaycastHit _hitInfo; + + var gen_ret = UnityEngine.Physics.Linecast( _start, _end, out _hitInfo ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _start;translator.Get(L, 1, out _start); + UnityEngine.Vector3 _end;translator.Get(L, 2, out _end); + UnityEngine.RaycastHit _hitInfo; + int _layerMask = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = UnityEngine.Physics.Linecast( _start, _end, out _hitInfo, _layerMask ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Vector3 _start;translator.Get(L, 1, out _start); + UnityEngine.Vector3 _end;translator.Get(L, 2, out _end); + int _layerMask = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 4, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.Linecast( _start, _end, _layerMask, _queryTriggerInteraction ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Vector3 _start;translator.Get(L, 1, out _start); + UnityEngine.Vector3 _end;translator.Get(L, 2, out _end); + UnityEngine.RaycastHit _hitInfo; + int _layerMask = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 4, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.Linecast( _start, _end, out _hitInfo, _layerMask, _queryTriggerInteraction ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Physics.Linecast!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CapsuleCast_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Vector3 _point1;translator.Get(L, 1, out _point1); + UnityEngine.Vector3 _point2;translator.Get(L, 2, out _point2); + float _radius = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Vector3 _direction;translator.Get(L, 4, out _direction); + + var gen_ret = UnityEngine.Physics.CapsuleCast( _point1, _point2, _radius, _direction ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Vector3 _point1;translator.Get(L, 1, out _point1); + UnityEngine.Vector3 _point2;translator.Get(L, 2, out _point2); + float _radius = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Vector3 _direction;translator.Get(L, 4, out _direction); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = UnityEngine.Physics.CapsuleCast( _point1, _point2, _radius, _direction, _maxDistance ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Vector3 _point1;translator.Get(L, 1, out _point1); + UnityEngine.Vector3 _point2;translator.Get(L, 2, out _point2); + float _radius = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Vector3 _direction;translator.Get(L, 4, out _direction); + UnityEngine.RaycastHit _hitInfo; + + var gen_ret = UnityEngine.Physics.CapsuleCast( _point1, _point2, _radius, _direction, out _hitInfo ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Vector3 _point1;translator.Get(L, 1, out _point1); + UnityEngine.Vector3 _point2;translator.Get(L, 2, out _point2); + float _radius = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Vector3 _direction;translator.Get(L, 4, out _direction); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 5); + int _layerMask = LuaAPI.xlua_tointeger(L, 6); + + var gen_ret = UnityEngine.Physics.CapsuleCast( _point1, _point2, _radius, _direction, _maxDistance, _layerMask ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Vector3 _point1;translator.Get(L, 1, out _point1); + UnityEngine.Vector3 _point2;translator.Get(L, 2, out _point2); + float _radius = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Vector3 _direction;translator.Get(L, 4, out _direction); + UnityEngine.RaycastHit _hitInfo; + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = UnityEngine.Physics.CapsuleCast( _point1, _point2, _radius, _direction, out _hitInfo, _maxDistance ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Vector3 _point1;translator.Get(L, 1, out _point1); + UnityEngine.Vector3 _point2;translator.Get(L, 2, out _point2); + float _radius = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Vector3 _direction;translator.Get(L, 4, out _direction); + UnityEngine.RaycastHit _hitInfo; + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 5); + int _layerMask = LuaAPI.xlua_tointeger(L, 6); + + var gen_ret = UnityEngine.Physics.CapsuleCast( _point1, _point2, _radius, _direction, out _hitInfo, _maxDistance, _layerMask ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + if(gen_param_count == 7&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)) + { + UnityEngine.Vector3 _point1;translator.Get(L, 1, out _point1); + UnityEngine.Vector3 _point2;translator.Get(L, 2, out _point2); + float _radius = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Vector3 _direction;translator.Get(L, 4, out _direction); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 5); + int _layerMask = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 7, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.CapsuleCast( _point1, _point2, _radius, _direction, _maxDistance, _layerMask, _queryTriggerInteraction ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 7&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)) + { + UnityEngine.Vector3 _point1;translator.Get(L, 1, out _point1); + UnityEngine.Vector3 _point2;translator.Get(L, 2, out _point2); + float _radius = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Vector3 _direction;translator.Get(L, 4, out _direction); + UnityEngine.RaycastHit _hitInfo; + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 5); + int _layerMask = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 7, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.CapsuleCast( _point1, _point2, _radius, _direction, out _hitInfo, _maxDistance, _layerMask, _queryTriggerInteraction ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Physics.CapsuleCast!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SphereCast_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = UnityEngine.Physics.SphereCast( _ray, _radius ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Physics.SphereCast( _ray, _radius, _maxDistance ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.RaycastHit _hitInfo; + + var gen_ret = UnityEngine.Physics.SphereCast( _ray, _radius, out _hitInfo ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 3); + int _layerMask = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = UnityEngine.Physics.SphereCast( _ray, _radius, _maxDistance, _layerMask ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.RaycastHit _hitInfo; + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Physics.SphereCast( _ray, _radius, out _hitInfo, _maxDistance ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.RaycastHit _hitInfo; + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 3); + int _layerMask = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = UnityEngine.Physics.SphereCast( _ray, _radius, out _hitInfo, _maxDistance, _layerMask ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _origin;translator.Get(L, 1, out _origin); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + UnityEngine.RaycastHit _hitInfo; + + var gen_ret = UnityEngine.Physics.SphereCast( _origin, _radius, _direction, out _hitInfo ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3 _origin;translator.Get(L, 1, out _origin); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + UnityEngine.RaycastHit _hitInfo; + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = UnityEngine.Physics.SphereCast( _origin, _radius, _direction, out _hitInfo, _maxDistance ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 3); + int _layerMask = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 5, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.SphereCast( _ray, _radius, _maxDistance, _layerMask, _queryTriggerInteraction ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Vector3 _origin;translator.Get(L, 1, out _origin); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + UnityEngine.RaycastHit _hitInfo; + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 4); + int _layerMask = LuaAPI.xlua_tointeger(L, 5); + + var gen_ret = UnityEngine.Physics.SphereCast( _origin, _radius, _direction, out _hitInfo, _maxDistance, _layerMask ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.RaycastHit _hitInfo; + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 3); + int _layerMask = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 5, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.SphereCast( _ray, _radius, out _hitInfo, _maxDistance, _layerMask, _queryTriggerInteraction ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)) + { + UnityEngine.Vector3 _origin;translator.Get(L, 1, out _origin); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + UnityEngine.RaycastHit _hitInfo; + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 4); + int _layerMask = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 6, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.SphereCast( _origin, _radius, _direction, out _hitInfo, _maxDistance, _layerMask, _queryTriggerInteraction ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Physics.SphereCast!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_BoxCast_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + + var gen_ret = UnityEngine.Physics.BoxCast( _center, _halfExtents, _direction ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + UnityEngine.RaycastHit _hitInfo; + + var gen_ret = UnityEngine.Physics.BoxCast( _center, _halfExtents, _direction, out _hitInfo ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + UnityEngine.Quaternion _orientation;translator.Get(L, 4, out _orientation); + + var gen_ret = UnityEngine.Physics.BoxCast( _center, _halfExtents, _direction, _orientation ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + UnityEngine.Quaternion _orientation;translator.Get(L, 4, out _orientation); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = UnityEngine.Physics.BoxCast( _center, _halfExtents, _direction, _orientation, _maxDistance ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + UnityEngine.RaycastHit _hitInfo; + UnityEngine.Quaternion _orientation;translator.Get(L, 4, out _orientation); + + var gen_ret = UnityEngine.Physics.BoxCast( _center, _halfExtents, _direction, out _hitInfo, _orientation ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + UnityEngine.Quaternion _orientation;translator.Get(L, 4, out _orientation); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 5); + int _layerMask = LuaAPI.xlua_tointeger(L, 6); + + var gen_ret = UnityEngine.Physics.BoxCast( _center, _halfExtents, _direction, _orientation, _maxDistance, _layerMask ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + UnityEngine.RaycastHit _hitInfo; + UnityEngine.Quaternion _orientation;translator.Get(L, 4, out _orientation); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = UnityEngine.Physics.BoxCast( _center, _halfExtents, _direction, out _hitInfo, _orientation, _maxDistance ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + UnityEngine.RaycastHit _hitInfo; + UnityEngine.Quaternion _orientation;translator.Get(L, 4, out _orientation); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 5); + int _layerMask = LuaAPI.xlua_tointeger(L, 6); + + var gen_ret = UnityEngine.Physics.BoxCast( _center, _halfExtents, _direction, out _hitInfo, _orientation, _maxDistance, _layerMask ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + if(gen_param_count == 7&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + UnityEngine.Quaternion _orientation;translator.Get(L, 4, out _orientation); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 5); + int _layerMask = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 7, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.BoxCast( _center, _halfExtents, _direction, _orientation, _maxDistance, _layerMask, _queryTriggerInteraction ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 7&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + UnityEngine.RaycastHit _hitInfo; + UnityEngine.Quaternion _orientation;translator.Get(L, 4, out _orientation); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 5); + int _layerMask = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 7, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.BoxCast( _center, _halfExtents, _direction, out _hitInfo, _orientation, _maxDistance, _layerMask, _queryTriggerInteraction ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Physics.BoxCast!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RaycastAll_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + + var gen_ret = UnityEngine.Physics.RaycastAll( _ray ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = UnityEngine.Physics.RaycastAll( _ray, _maxDistance ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 2); + int _layerMask = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = UnityEngine.Physics.RaycastAll( _ray, _maxDistance, _layerMask ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _origin;translator.Get(L, 1, out _origin); + UnityEngine.Vector3 _direction;translator.Get(L, 2, out _direction); + + var gen_ret = UnityEngine.Physics.RaycastAll( _origin, _direction ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _origin;translator.Get(L, 1, out _origin); + UnityEngine.Vector3 _direction;translator.Get(L, 2, out _direction); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Physics.RaycastAll( _origin, _direction, _maxDistance ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3 _origin;translator.Get(L, 1, out _origin); + UnityEngine.Vector3 _direction;translator.Get(L, 2, out _direction); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 3); + int _layerMask = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = UnityEngine.Physics.RaycastAll( _origin, _direction, _maxDistance, _layerMask ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 2); + int _layerMask = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 4, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.RaycastAll( _ray, _maxDistance, _layerMask, _queryTriggerInteraction ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + UnityEngine.Vector3 _origin;translator.Get(L, 1, out _origin); + UnityEngine.Vector3 _direction;translator.Get(L, 2, out _direction); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 3); + int _layerMask = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 5, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.RaycastAll( _origin, _direction, _maxDistance, _layerMask, _queryTriggerInteraction ); + 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 UnityEngine.Physics.RaycastAll!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RaycastNonAlloc_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + UnityEngine.RaycastHit[] _results = (UnityEngine.RaycastHit[])translator.GetObject(L, 2, typeof(UnityEngine.RaycastHit[])); + + var gen_ret = UnityEngine.Physics.RaycastNonAlloc( _ray, _results ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + UnityEngine.RaycastHit[] _results = (UnityEngine.RaycastHit[])translator.GetObject(L, 2, typeof(UnityEngine.RaycastHit[])); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Physics.RaycastNonAlloc( _ray, _results, _maxDistance ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + UnityEngine.RaycastHit[] _results = (UnityEngine.RaycastHit[])translator.GetObject(L, 2, typeof(UnityEngine.RaycastHit[])); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 3); + int _layerMask = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = UnityEngine.Physics.RaycastNonAlloc( _ray, _results, _maxDistance, _layerMask ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _origin;translator.Get(L, 1, out _origin); + UnityEngine.Vector3 _direction;translator.Get(L, 2, out _direction); + UnityEngine.RaycastHit[] _results = (UnityEngine.RaycastHit[])translator.GetObject(L, 3, typeof(UnityEngine.RaycastHit[])); + + var gen_ret = UnityEngine.Physics.RaycastNonAlloc( _origin, _direction, _results ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3 _origin;translator.Get(L, 1, out _origin); + UnityEngine.Vector3 _direction;translator.Get(L, 2, out _direction); + UnityEngine.RaycastHit[] _results = (UnityEngine.RaycastHit[])translator.GetObject(L, 3, typeof(UnityEngine.RaycastHit[])); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = UnityEngine.Physics.RaycastNonAlloc( _origin, _direction, _results, _maxDistance ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + UnityEngine.RaycastHit[] _results = (UnityEngine.RaycastHit[])translator.GetObject(L, 2, typeof(UnityEngine.RaycastHit[])); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 3); + int _layerMask = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 5, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.RaycastNonAlloc( _ray, _results, _maxDistance, _layerMask, _queryTriggerInteraction ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Vector3 _origin;translator.Get(L, 1, out _origin); + UnityEngine.Vector3 _direction;translator.Get(L, 2, out _direction); + UnityEngine.RaycastHit[] _results = (UnityEngine.RaycastHit[])translator.GetObject(L, 3, typeof(UnityEngine.RaycastHit[])); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 4); + int _layerMask = LuaAPI.xlua_tointeger(L, 5); + + var gen_ret = UnityEngine.Physics.RaycastNonAlloc( _origin, _direction, _results, _maxDistance, _layerMask ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)) + { + UnityEngine.Vector3 _origin;translator.Get(L, 1, out _origin); + UnityEngine.Vector3 _direction;translator.Get(L, 2, out _direction); + UnityEngine.RaycastHit[] _results = (UnityEngine.RaycastHit[])translator.GetObject(L, 3, typeof(UnityEngine.RaycastHit[])); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 4); + int _layerMask = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 6, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.RaycastNonAlloc( _origin, _direction, _results, _maxDistance, _layerMask, _queryTriggerInteraction ); + LuaAPI.xlua_pushinteger(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 UnityEngine.Physics.RaycastNonAlloc!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CapsuleCastAll_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Vector3 _point1;translator.Get(L, 1, out _point1); + UnityEngine.Vector3 _point2;translator.Get(L, 2, out _point2); + float _radius = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Vector3 _direction;translator.Get(L, 4, out _direction); + + var gen_ret = UnityEngine.Physics.CapsuleCastAll( _point1, _point2, _radius, _direction ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Vector3 _point1;translator.Get(L, 1, out _point1); + UnityEngine.Vector3 _point2;translator.Get(L, 2, out _point2); + float _radius = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Vector3 _direction;translator.Get(L, 4, out _direction); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = UnityEngine.Physics.CapsuleCastAll( _point1, _point2, _radius, _direction, _maxDistance ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Vector3 _point1;translator.Get(L, 1, out _point1); + UnityEngine.Vector3 _point2;translator.Get(L, 2, out _point2); + float _radius = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Vector3 _direction;translator.Get(L, 4, out _direction); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 5); + int _layerMask = LuaAPI.xlua_tointeger(L, 6); + + var gen_ret = UnityEngine.Physics.CapsuleCastAll( _point1, _point2, _radius, _direction, _maxDistance, _layerMask ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 7&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)) + { + UnityEngine.Vector3 _point1;translator.Get(L, 1, out _point1); + UnityEngine.Vector3 _point2;translator.Get(L, 2, out _point2); + float _radius = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Vector3 _direction;translator.Get(L, 4, out _direction); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 5); + int _layerMask = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 7, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.CapsuleCastAll( _point1, _point2, _radius, _direction, _maxDistance, _layerMask, _queryTriggerInteraction ); + 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 UnityEngine.Physics.CapsuleCastAll!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SphereCastAll_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = UnityEngine.Physics.SphereCastAll( _ray, _radius ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Physics.SphereCastAll( _ray, _radius, _maxDistance ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 3); + int _layerMask = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = UnityEngine.Physics.SphereCastAll( _ray, _radius, _maxDistance, _layerMask ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _origin;translator.Get(L, 1, out _origin); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + + var gen_ret = UnityEngine.Physics.SphereCastAll( _origin, _radius, _direction ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3 _origin;translator.Get(L, 1, out _origin); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = UnityEngine.Physics.SphereCastAll( _origin, _radius, _direction, _maxDistance ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Vector3 _origin;translator.Get(L, 1, out _origin); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 4); + int _layerMask = LuaAPI.xlua_tointeger(L, 5); + + var gen_ret = UnityEngine.Physics.SphereCastAll( _origin, _radius, _direction, _maxDistance, _layerMask ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 3); + int _layerMask = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 5, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.SphereCastAll( _ray, _radius, _maxDistance, _layerMask, _queryTriggerInteraction ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)) + { + UnityEngine.Vector3 _origin;translator.Get(L, 1, out _origin); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 4); + int _layerMask = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 6, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.SphereCastAll( _origin, _radius, _direction, _maxDistance, _layerMask, _queryTriggerInteraction ); + 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 UnityEngine.Physics.SphereCastAll!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OverlapCapsule_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _point0;translator.Get(L, 1, out _point0); + UnityEngine.Vector3 _point1;translator.Get(L, 2, out _point1); + float _radius = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Physics.OverlapCapsule( _point0, _point1, _radius ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3 _point0;translator.Get(L, 1, out _point0); + UnityEngine.Vector3 _point1;translator.Get(L, 2, out _point1); + float _radius = (float)LuaAPI.lua_tonumber(L, 3); + int _layerMask = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = UnityEngine.Physics.OverlapCapsule( _point0, _point1, _radius, _layerMask ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + UnityEngine.Vector3 _point0;translator.Get(L, 1, out _point0); + UnityEngine.Vector3 _point1;translator.Get(L, 2, out _point1); + float _radius = (float)LuaAPI.lua_tonumber(L, 3); + int _layerMask = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 5, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.OverlapCapsule( _point0, _point1, _radius, _layerMask, _queryTriggerInteraction ); + 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 UnityEngine.Physics.OverlapCapsule!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OverlapSphere_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + UnityEngine.Vector3 _position;translator.Get(L, 1, out _position); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = UnityEngine.Physics.OverlapSphere( _position, _radius ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _position;translator.Get(L, 1, out _position); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + int _layerMask = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = UnityEngine.Physics.OverlapSphere( _position, _radius, _layerMask ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Vector3 _position;translator.Get(L, 1, out _position); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + int _layerMask = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 4, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.OverlapSphere( _position, _radius, _layerMask, _queryTriggerInteraction ); + 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 UnityEngine.Physics.OverlapSphere!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Simulate_xlua_st_(RealStatePtr L) + { + try { + + + + + { + float _step = (float)LuaAPI.lua_tonumber(L, 1); + + UnityEngine.Physics.Simulate( _step ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SyncTransforms_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + UnityEngine.Physics.SyncTransforms( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ComputePenetration_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Collider _colliderA = (UnityEngine.Collider)translator.GetObject(L, 1, typeof(UnityEngine.Collider)); + UnityEngine.Vector3 _positionA;translator.Get(L, 2, out _positionA); + UnityEngine.Quaternion _rotationA;translator.Get(L, 3, out _rotationA); + UnityEngine.Collider _colliderB = (UnityEngine.Collider)translator.GetObject(L, 4, typeof(UnityEngine.Collider)); + UnityEngine.Vector3 _positionB;translator.Get(L, 5, out _positionB); + UnityEngine.Quaternion _rotationB;translator.Get(L, 6, out _rotationB); + UnityEngine.Vector3 _direction; + float _distance; + + var gen_ret = UnityEngine.Physics.ComputePenetration( _colliderA, _positionA, _rotationA, _colliderB, _positionB, _rotationB, out _direction, out _distance ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.PushUnityEngineVector3(L, _direction); + + LuaAPI.lua_pushnumber(L, _distance); + + + + + return 3; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClosestPoint_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector3 _point;translator.Get(L, 1, out _point); + UnityEngine.Collider _collider = (UnityEngine.Collider)translator.GetObject(L, 2, typeof(UnityEngine.Collider)); + UnityEngine.Vector3 _position;translator.Get(L, 3, out _position); + UnityEngine.Quaternion _rotation;translator.Get(L, 4, out _rotation); + + var gen_ret = UnityEngine.Physics.ClosestPoint( _point, _collider, _position, _rotation ); + translator.PushUnityEngineVector3(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_OverlapSphereNonAlloc_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _position;translator.Get(L, 1, out _position); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Collider[] _results = (UnityEngine.Collider[])translator.GetObject(L, 3, typeof(UnityEngine.Collider[])); + + var gen_ret = UnityEngine.Physics.OverlapSphereNonAlloc( _position, _radius, _results ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3 _position;translator.Get(L, 1, out _position); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Collider[] _results = (UnityEngine.Collider[])translator.GetObject(L, 3, typeof(UnityEngine.Collider[])); + int _layerMask = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = UnityEngine.Physics.OverlapSphereNonAlloc( _position, _radius, _results, _layerMask ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + UnityEngine.Vector3 _position;translator.Get(L, 1, out _position); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Collider[] _results = (UnityEngine.Collider[])translator.GetObject(L, 3, typeof(UnityEngine.Collider[])); + int _layerMask = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 5, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.OverlapSphereNonAlloc( _position, _radius, _results, _layerMask, _queryTriggerInteraction ); + LuaAPI.xlua_pushinteger(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 UnityEngine.Physics.OverlapSphereNonAlloc!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CheckSphere_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + UnityEngine.Vector3 _position;translator.Get(L, 1, out _position); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = UnityEngine.Physics.CheckSphere( _position, _radius ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _position;translator.Get(L, 1, out _position); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + int _layerMask = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = UnityEngine.Physics.CheckSphere( _position, _radius, _layerMask ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Vector3 _position;translator.Get(L, 1, out _position); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + int _layerMask = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 4, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.CheckSphere( _position, _radius, _layerMask, _queryTriggerInteraction ); + LuaAPI.lua_pushboolean(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 UnityEngine.Physics.CheckSphere!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CapsuleCastNonAlloc_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)) + { + UnityEngine.Vector3 _point1;translator.Get(L, 1, out _point1); + UnityEngine.Vector3 _point2;translator.Get(L, 2, out _point2); + float _radius = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Vector3 _direction;translator.Get(L, 4, out _direction); + UnityEngine.RaycastHit[] _results = (UnityEngine.RaycastHit[])translator.GetObject(L, 5, typeof(UnityEngine.RaycastHit[])); + + var gen_ret = UnityEngine.Physics.CapsuleCastNonAlloc( _point1, _point2, _radius, _direction, _results ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Vector3 _point1;translator.Get(L, 1, out _point1); + UnityEngine.Vector3 _point2;translator.Get(L, 2, out _point2); + float _radius = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Vector3 _direction;translator.Get(L, 4, out _direction); + UnityEngine.RaycastHit[] _results = (UnityEngine.RaycastHit[])translator.GetObject(L, 5, typeof(UnityEngine.RaycastHit[])); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 6); + + var gen_ret = UnityEngine.Physics.CapsuleCastNonAlloc( _point1, _point2, _radius, _direction, _results, _maxDistance ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 7&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)) + { + UnityEngine.Vector3 _point1;translator.Get(L, 1, out _point1); + UnityEngine.Vector3 _point2;translator.Get(L, 2, out _point2); + float _radius = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Vector3 _direction;translator.Get(L, 4, out _direction); + UnityEngine.RaycastHit[] _results = (UnityEngine.RaycastHit[])translator.GetObject(L, 5, typeof(UnityEngine.RaycastHit[])); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 6); + int _layerMask = LuaAPI.xlua_tointeger(L, 7); + + var gen_ret = UnityEngine.Physics.CapsuleCastNonAlloc( _point1, _point2, _radius, _direction, _results, _maxDistance, _layerMask ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 8&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)&& translator.Assignable(L, 8)) + { + UnityEngine.Vector3 _point1;translator.Get(L, 1, out _point1); + UnityEngine.Vector3 _point2;translator.Get(L, 2, out _point2); + float _radius = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Vector3 _direction;translator.Get(L, 4, out _direction); + UnityEngine.RaycastHit[] _results = (UnityEngine.RaycastHit[])translator.GetObject(L, 5, typeof(UnityEngine.RaycastHit[])); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 6); + int _layerMask = LuaAPI.xlua_tointeger(L, 7); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 8, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.CapsuleCastNonAlloc( _point1, _point2, _radius, _direction, _results, _maxDistance, _layerMask, _queryTriggerInteraction ); + LuaAPI.xlua_pushinteger(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 UnityEngine.Physics.CapsuleCastNonAlloc!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SphereCastNonAlloc_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.RaycastHit[] _results = (UnityEngine.RaycastHit[])translator.GetObject(L, 3, typeof(UnityEngine.RaycastHit[])); + + var gen_ret = UnityEngine.Physics.SphereCastNonAlloc( _ray, _radius, _results ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.RaycastHit[] _results = (UnityEngine.RaycastHit[])translator.GetObject(L, 3, typeof(UnityEngine.RaycastHit[])); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = UnityEngine.Physics.SphereCastNonAlloc( _ray, _radius, _results, _maxDistance ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.RaycastHit[] _results = (UnityEngine.RaycastHit[])translator.GetObject(L, 3, typeof(UnityEngine.RaycastHit[])); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 4); + int _layerMask = LuaAPI.xlua_tointeger(L, 5); + + var gen_ret = UnityEngine.Physics.SphereCastNonAlloc( _ray, _radius, _results, _maxDistance, _layerMask ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Vector3 _origin;translator.Get(L, 1, out _origin); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + UnityEngine.RaycastHit[] _results = (UnityEngine.RaycastHit[])translator.GetObject(L, 4, typeof(UnityEngine.RaycastHit[])); + + var gen_ret = UnityEngine.Physics.SphereCastNonAlloc( _origin, _radius, _direction, _results ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Vector3 _origin;translator.Get(L, 1, out _origin); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + UnityEngine.RaycastHit[] _results = (UnityEngine.RaycastHit[])translator.GetObject(L, 4, typeof(UnityEngine.RaycastHit[])); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = UnityEngine.Physics.SphereCastNonAlloc( _origin, _radius, _direction, _results, _maxDistance ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Vector3 _origin;translator.Get(L, 1, out _origin); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + UnityEngine.RaycastHit[] _results = (UnityEngine.RaycastHit[])translator.GetObject(L, 4, typeof(UnityEngine.RaycastHit[])); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 5); + int _layerMask = LuaAPI.xlua_tointeger(L, 6); + + var gen_ret = UnityEngine.Physics.SphereCastNonAlloc( _origin, _radius, _direction, _results, _maxDistance, _layerMask ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)) + { + UnityEngine.Ray _ray;translator.Get(L, 1, out _ray); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.RaycastHit[] _results = (UnityEngine.RaycastHit[])translator.GetObject(L, 3, typeof(UnityEngine.RaycastHit[])); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 4); + int _layerMask = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 6, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.SphereCastNonAlloc( _ray, _radius, _results, _maxDistance, _layerMask, _queryTriggerInteraction ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 7&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)) + { + UnityEngine.Vector3 _origin;translator.Get(L, 1, out _origin); + float _radius = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + UnityEngine.RaycastHit[] _results = (UnityEngine.RaycastHit[])translator.GetObject(L, 4, typeof(UnityEngine.RaycastHit[])); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 5); + int _layerMask = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 7, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.SphereCastNonAlloc( _origin, _radius, _direction, _results, _maxDistance, _layerMask, _queryTriggerInteraction ); + LuaAPI.xlua_pushinteger(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 UnityEngine.Physics.SphereCastNonAlloc!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CheckCapsule_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _start;translator.Get(L, 1, out _start); + UnityEngine.Vector3 _end;translator.Get(L, 2, out _end); + float _radius = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Physics.CheckCapsule( _start, _end, _radius ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3 _start;translator.Get(L, 1, out _start); + UnityEngine.Vector3 _end;translator.Get(L, 2, out _end); + float _radius = (float)LuaAPI.lua_tonumber(L, 3); + int _layerMask = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = UnityEngine.Physics.CheckCapsule( _start, _end, _radius, _layerMask ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + UnityEngine.Vector3 _start;translator.Get(L, 1, out _start); + UnityEngine.Vector3 _end;translator.Get(L, 2, out _end); + float _radius = (float)LuaAPI.lua_tonumber(L, 3); + int _layerMask = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 5, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.CheckCapsule( _start, _end, _radius, _layerMask, _queryTriggerInteraction ); + LuaAPI.lua_pushboolean(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 UnityEngine.Physics.CheckCapsule!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CheckBox_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + + var gen_ret = UnityEngine.Physics.CheckBox( _center, _halfExtents ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Quaternion _orientation;translator.Get(L, 3, out _orientation); + + var gen_ret = UnityEngine.Physics.CheckBox( _center, _halfExtents, _orientation ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Quaternion _orientation;translator.Get(L, 3, out _orientation); + int _layerMask = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = UnityEngine.Physics.CheckBox( _center, _halfExtents, _orientation, _layerMask ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Quaternion _orientation;translator.Get(L, 3, out _orientation); + int _layermask = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 5, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.CheckBox( _center, _halfExtents, _orientation, _layermask, _queryTriggerInteraction ); + LuaAPI.lua_pushboolean(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 UnityEngine.Physics.CheckBox!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OverlapBox_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + + var gen_ret = UnityEngine.Physics.OverlapBox( _center, _halfExtents ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Quaternion _orientation;translator.Get(L, 3, out _orientation); + + var gen_ret = UnityEngine.Physics.OverlapBox( _center, _halfExtents, _orientation ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Quaternion _orientation;translator.Get(L, 3, out _orientation); + int _layerMask = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = UnityEngine.Physics.OverlapBox( _center, _halfExtents, _orientation, _layerMask ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Quaternion _orientation;translator.Get(L, 3, out _orientation); + int _layerMask = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 5, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.OverlapBox( _center, _halfExtents, _orientation, _layerMask, _queryTriggerInteraction ); + 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 UnityEngine.Physics.OverlapBox!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OverlapBoxNonAlloc_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Collider[] _results = (UnityEngine.Collider[])translator.GetObject(L, 3, typeof(UnityEngine.Collider[])); + + var gen_ret = UnityEngine.Physics.OverlapBoxNonAlloc( _center, _halfExtents, _results ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Collider[] _results = (UnityEngine.Collider[])translator.GetObject(L, 3, typeof(UnityEngine.Collider[])); + UnityEngine.Quaternion _orientation;translator.Get(L, 4, out _orientation); + + var gen_ret = UnityEngine.Physics.OverlapBoxNonAlloc( _center, _halfExtents, _results, _orientation ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Collider[] _results = (UnityEngine.Collider[])translator.GetObject(L, 3, typeof(UnityEngine.Collider[])); + UnityEngine.Quaternion _orientation;translator.Get(L, 4, out _orientation); + int _mask = LuaAPI.xlua_tointeger(L, 5); + + var gen_ret = UnityEngine.Physics.OverlapBoxNonAlloc( _center, _halfExtents, _results, _orientation, _mask ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Collider[] _results = (UnityEngine.Collider[])translator.GetObject(L, 3, typeof(UnityEngine.Collider[])); + UnityEngine.Quaternion _orientation;translator.Get(L, 4, out _orientation); + int _mask = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 6, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.OverlapBoxNonAlloc( _center, _halfExtents, _results, _orientation, _mask, _queryTriggerInteraction ); + LuaAPI.xlua_pushinteger(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 UnityEngine.Physics.OverlapBoxNonAlloc!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_BoxCastNonAlloc_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + UnityEngine.RaycastHit[] _results = (UnityEngine.RaycastHit[])translator.GetObject(L, 4, typeof(UnityEngine.RaycastHit[])); + + var gen_ret = UnityEngine.Physics.BoxCastNonAlloc( _center, _halfExtents, _direction, _results ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + UnityEngine.RaycastHit[] _results = (UnityEngine.RaycastHit[])translator.GetObject(L, 4, typeof(UnityEngine.RaycastHit[])); + UnityEngine.Quaternion _orientation;translator.Get(L, 5, out _orientation); + + var gen_ret = UnityEngine.Physics.BoxCastNonAlloc( _center, _halfExtents, _direction, _results, _orientation ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + UnityEngine.RaycastHit[] _results = (UnityEngine.RaycastHit[])translator.GetObject(L, 4, typeof(UnityEngine.RaycastHit[])); + UnityEngine.Quaternion _orientation;translator.Get(L, 5, out _orientation); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 6); + + var gen_ret = UnityEngine.Physics.BoxCastNonAlloc( _center, _halfExtents, _direction, _results, _orientation, _maxDistance ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 7&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + UnityEngine.RaycastHit[] _results = (UnityEngine.RaycastHit[])translator.GetObject(L, 4, typeof(UnityEngine.RaycastHit[])); + UnityEngine.Quaternion _orientation;translator.Get(L, 5, out _orientation); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 6); + int _layerMask = LuaAPI.xlua_tointeger(L, 7); + + var gen_ret = UnityEngine.Physics.BoxCastNonAlloc( _center, _halfExtents, _direction, _results, _orientation, _maxDistance, _layerMask ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 8&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)&& translator.Assignable(L, 8)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + UnityEngine.RaycastHit[] _results = (UnityEngine.RaycastHit[])translator.GetObject(L, 4, typeof(UnityEngine.RaycastHit[])); + UnityEngine.Quaternion _orientation;translator.Get(L, 5, out _orientation); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 6); + int _layerMask = LuaAPI.xlua_tointeger(L, 7); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 8, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.BoxCastNonAlloc( _center, _halfExtents, _direction, _results, _orientation, _maxDistance, _layerMask, _queryTriggerInteraction ); + LuaAPI.xlua_pushinteger(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 UnityEngine.Physics.BoxCastNonAlloc!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_BoxCastAll_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + + var gen_ret = UnityEngine.Physics.BoxCastAll( _center, _halfExtents, _direction ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + UnityEngine.Quaternion _orientation;translator.Get(L, 4, out _orientation); + + var gen_ret = UnityEngine.Physics.BoxCastAll( _center, _halfExtents, _direction, _orientation ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + UnityEngine.Quaternion _orientation;translator.Get(L, 4, out _orientation); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = UnityEngine.Physics.BoxCastAll( _center, _halfExtents, _direction, _orientation, _maxDistance ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + UnityEngine.Quaternion _orientation;translator.Get(L, 4, out _orientation); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 5); + int _layerMask = LuaAPI.xlua_tointeger(L, 6); + + var gen_ret = UnityEngine.Physics.BoxCastAll( _center, _halfExtents, _direction, _orientation, _maxDistance, _layerMask ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 7&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)) + { + UnityEngine.Vector3 _center;translator.Get(L, 1, out _center); + UnityEngine.Vector3 _halfExtents;translator.Get(L, 2, out _halfExtents); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + UnityEngine.Quaternion _orientation;translator.Get(L, 4, out _orientation); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 5); + int _layerMask = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 7, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.BoxCastAll( _center, _halfExtents, _direction, _orientation, _maxDistance, _layerMask, _queryTriggerInteraction ); + 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 UnityEngine.Physics.BoxCastAll!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OverlapCapsuleNonAlloc_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Vector3 _point0;translator.Get(L, 1, out _point0); + UnityEngine.Vector3 _point1;translator.Get(L, 2, out _point1); + float _radius = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Collider[] _results = (UnityEngine.Collider[])translator.GetObject(L, 4, typeof(UnityEngine.Collider[])); + + var gen_ret = UnityEngine.Physics.OverlapCapsuleNonAlloc( _point0, _point1, _radius, _results ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Vector3 _point0;translator.Get(L, 1, out _point0); + UnityEngine.Vector3 _point1;translator.Get(L, 2, out _point1); + float _radius = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Collider[] _results = (UnityEngine.Collider[])translator.GetObject(L, 4, typeof(UnityEngine.Collider[])); + int _layerMask = LuaAPI.xlua_tointeger(L, 5); + + var gen_ret = UnityEngine.Physics.OverlapCapsuleNonAlloc( _point0, _point1, _radius, _results, _layerMask ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)) + { + UnityEngine.Vector3 _point0;translator.Get(L, 1, out _point0); + UnityEngine.Vector3 _point1;translator.Get(L, 2, out _point1); + float _radius = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Collider[] _results = (UnityEngine.Collider[])translator.GetObject(L, 4, typeof(UnityEngine.Collider[])); + int _layerMask = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 6, out _queryTriggerInteraction); + + var gen_ret = UnityEngine.Physics.OverlapCapsuleNonAlloc( _point0, _point1, _radius, _results, _layerMask, _queryTriggerInteraction ); + LuaAPI.xlua_pushinteger(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 UnityEngine.Physics.OverlapCapsuleNonAlloc!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RebuildBroadphaseRegions_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Bounds _worldBounds;translator.Get(L, 1, out _worldBounds); + int _subdivisions = LuaAPI.xlua_tointeger(L, 2); + + UnityEngine.Physics.RebuildBroadphaseRegions( _worldBounds, _subdivisions ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_BakeMesh_xlua_st_(RealStatePtr L) + { + try { + + + + + { + int _meshID = LuaAPI.xlua_tointeger(L, 1); + bool _convex = LuaAPI.lua_toboolean(L, 2); + + UnityEngine.Physics.BakeMesh( _meshID, _convex ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_gravity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineVector3(L, UnityEngine.Physics.gravity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_defaultContactOffset(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Physics.defaultContactOffset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sleepThreshold(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Physics.sleepThreshold); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_queriesHitTriggers(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Physics.queriesHitTriggers); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_queriesHitBackfaces(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Physics.queriesHitBackfaces); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bounceThreshold(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Physics.bounceThreshold); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_defaultMaxDepenetrationVelocity(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Physics.defaultMaxDepenetrationVelocity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_defaultSolverIterations(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.Physics.defaultSolverIterations); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_defaultSolverVelocityIterations(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.Physics.defaultSolverVelocityIterations); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_defaultMaxAngularSpeed(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Physics.defaultMaxAngularSpeed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_improvedPatchFriction(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Physics.improvedPatchFriction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_defaultPhysicsScene(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Physics.defaultPhysicsScene); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_autoSimulation(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Physics.autoSimulation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_autoSyncTransforms(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Physics.autoSyncTransforms); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_reuseCollisionCallbacks(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Physics.reuseCollisionCallbacks); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_interCollisionDistance(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Physics.interCollisionDistance); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_interCollisionStiffness(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Physics.interCollisionStiffness); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_interCollisionSettingsToggle(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Physics.interCollisionSettingsToggle); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_clothGravity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineVector3(L, UnityEngine.Physics.clothGravity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_gravity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + UnityEngine.Vector3 gen_value;translator.Get(L, 1, out gen_value); + UnityEngine.Physics.gravity = 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_defaultContactOffset(RealStatePtr L) + { + try { + + UnityEngine.Physics.defaultContactOffset = (float)LuaAPI.lua_tonumber(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_sleepThreshold(RealStatePtr L) + { + try { + + UnityEngine.Physics.sleepThreshold = (float)LuaAPI.lua_tonumber(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_queriesHitTriggers(RealStatePtr L) + { + try { + + UnityEngine.Physics.queriesHitTriggers = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_queriesHitBackfaces(RealStatePtr L) + { + try { + + UnityEngine.Physics.queriesHitBackfaces = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_bounceThreshold(RealStatePtr L) + { + try { + + UnityEngine.Physics.bounceThreshold = (float)LuaAPI.lua_tonumber(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_defaultMaxDepenetrationVelocity(RealStatePtr L) + { + try { + + UnityEngine.Physics.defaultMaxDepenetrationVelocity = (float)LuaAPI.lua_tonumber(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_defaultSolverIterations(RealStatePtr L) + { + try { + + UnityEngine.Physics.defaultSolverIterations = LuaAPI.xlua_tointeger(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_defaultSolverVelocityIterations(RealStatePtr L) + { + try { + + UnityEngine.Physics.defaultSolverVelocityIterations = LuaAPI.xlua_tointeger(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_defaultMaxAngularSpeed(RealStatePtr L) + { + try { + + UnityEngine.Physics.defaultMaxAngularSpeed = (float)LuaAPI.lua_tonumber(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_improvedPatchFriction(RealStatePtr L) + { + try { + + UnityEngine.Physics.improvedPatchFriction = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_autoSimulation(RealStatePtr L) + { + try { + + UnityEngine.Physics.autoSimulation = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_autoSyncTransforms(RealStatePtr L) + { + try { + + UnityEngine.Physics.autoSyncTransforms = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_reuseCollisionCallbacks(RealStatePtr L) + { + try { + + UnityEngine.Physics.reuseCollisionCallbacks = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_interCollisionDistance(RealStatePtr L) + { + try { + + UnityEngine.Physics.interCollisionDistance = (float)LuaAPI.lua_tonumber(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_interCollisionStiffness(RealStatePtr L) + { + try { + + UnityEngine.Physics.interCollisionStiffness = (float)LuaAPI.lua_tonumber(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_interCollisionSettingsToggle(RealStatePtr L) + { + try { + + UnityEngine.Physics.interCollisionSettingsToggle = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_clothGravity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + UnityEngine.Vector3 gen_value;translator.Get(L, 1, out gen_value); + UnityEngine.Physics.clothGravity = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_ContactModifyEvent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action> gen_delegate = translator.GetDelegate>>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action>!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + UnityEngine.Physics.ContactModifyEvent += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + UnityEngine.Physics.ContactModifyEvent -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Physics.ContactModifyEvent!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_ContactModifyEventCCD(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action> gen_delegate = translator.GetDelegate>>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action>!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + UnityEngine.Physics.ContactModifyEventCCD += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + UnityEngine.Physics.ContactModifyEventCCD -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Physics.ContactModifyEventCCD!"); + } + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_Playables_PlayableAssetWrap.cs b/Assets/XLua/Gen/UnityEngine_Playables_PlayableAssetWrap.cs new file mode 100644 index 000000000..bafb6a8b8 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_Playables_PlayableAssetWrap.cs @@ -0,0 +1,128 @@ +#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 UnityEnginePlayablesPlayableAssetWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Playables.PlayableAsset); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 2, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CreatePlayable", _m_CreatePlayable); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "duration", _g_get_duration); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "outputs", _g_get_outputs); + + + + 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, "UnityEngine.Playables.PlayableAsset does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CreatePlayable(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Playables.PlayableAsset gen_to_be_invoked = (UnityEngine.Playables.PlayableAsset)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Playables.PlayableGraph _graph;translator.Get(L, 2, out _graph); + UnityEngine.GameObject _owner = (UnityEngine.GameObject)translator.GetObject(L, 3, typeof(UnityEngine.GameObject)); + + var gen_ret = gen_to_be_invoked.CreatePlayable( _graph, _owner ); + 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_duration(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Playables.PlayableAsset gen_to_be_invoked = (UnityEngine.Playables.PlayableAsset)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.duration); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_outputs(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Playables.PlayableAsset gen_to_be_invoked = (UnityEngine.Playables.PlayableAsset)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.outputs); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_Playables_PlayableDirectorWrap.cs b/Assets/XLua/Gen/UnityEngine_Playables_PlayableDirectorWrap.cs new file mode 100644 index 000000000..1019768ff --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_Playables_PlayableDirectorWrap.cs @@ -0,0 +1,852 @@ +#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 UnityEnginePlayablesPlayableDirectorWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Playables.PlayableDirector); + Utils.BeginObjectRegister(type, L, translator, 0, 17, 9, 6); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DeferredEvaluate", _m_DeferredEvaluate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Play", _m_Play); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetGenericBinding", _m_SetGenericBinding); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Evaluate", _m_Evaluate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Stop", _m_Stop); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Pause", _m_Pause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Resume", _m_Resume); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RebuildGraph", _m_RebuildGraph); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearReferenceValue", _m_ClearReferenceValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetReferenceValue", _m_SetReferenceValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetReferenceValue", _m_GetReferenceValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetGenericBinding", _m_GetGenericBinding); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearGenericBinding", _m_ClearGenericBinding); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RebindPlayableGraphOutputs", _m_RebindPlayableGraphOutputs); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "played", _e_played); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "paused", _e_paused); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "stopped", _e_stopped); + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "state", _g_get_state); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "extrapolationMode", _g_get_extrapolationMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "playableAsset", _g_get_playableAsset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "playableGraph", _g_get_playableGraph); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "playOnAwake", _g_get_playOnAwake); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "timeUpdateMode", _g_get_timeUpdateMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "time", _g_get_time); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "initialTime", _g_get_initialTime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "duration", _g_get_duration); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "extrapolationMode", _s_set_extrapolationMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "playableAsset", _s_set_playableAsset); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "playOnAwake", _s_set_playOnAwake); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "timeUpdateMode", _s_set_timeUpdateMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "time", _s_set_time); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "initialTime", _s_set_initialTime); + + + 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 UnityEngine.Playables.PlayableDirector(); + 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 UnityEngine.Playables.PlayableDirector constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DeferredEvaluate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.DeferredEvaluate( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Play(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.Play( ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Playables.PlayableAsset _asset = (UnityEngine.Playables.PlayableAsset)translator.GetObject(L, 2, typeof(UnityEngine.Playables.PlayableAsset)); + + gen_to_be_invoked.Play( _asset ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Playables.PlayableAsset _asset = (UnityEngine.Playables.PlayableAsset)translator.GetObject(L, 2, typeof(UnityEngine.Playables.PlayableAsset)); + UnityEngine.Playables.DirectorWrapMode _mode;translator.Get(L, 3, out _mode); + + gen_to_be_invoked.Play( _asset, _mode ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Playables.PlayableDirector.Play!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetGenericBinding(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Object _key = (UnityEngine.Object)translator.GetObject(L, 2, typeof(UnityEngine.Object)); + UnityEngine.Object _value = (UnityEngine.Object)translator.GetObject(L, 3, typeof(UnityEngine.Object)); + + gen_to_be_invoked.SetGenericBinding( _key, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Evaluate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Evaluate( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Stop(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Stop( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Pause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Pause( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Resume(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Resume( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RebuildGraph(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RebuildGraph( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearReferenceValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.PropertyName _id;translator.Get(L, 2, out _id); + + gen_to_be_invoked.ClearReferenceValue( _id ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetReferenceValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.PropertyName _id;translator.Get(L, 2, out _id); + UnityEngine.Object _value = (UnityEngine.Object)translator.GetObject(L, 3, typeof(UnityEngine.Object)); + + gen_to_be_invoked.SetReferenceValue( _id, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetReferenceValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.PropertyName _id;translator.Get(L, 2, out _id); + bool _idValid; + + var gen_ret = gen_to_be_invoked.GetReferenceValue( _id, out _idValid ); + translator.Push(L, gen_ret); + LuaAPI.lua_pushboolean(L, _idValid); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetGenericBinding(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Object _key = (UnityEngine.Object)translator.GetObject(L, 2, typeof(UnityEngine.Object)); + + var gen_ret = gen_to_be_invoked.GetGenericBinding( _key ); + 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_ClearGenericBinding(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Object _key = (UnityEngine.Object)translator.GetObject(L, 2, typeof(UnityEngine.Object)); + + gen_to_be_invoked.ClearGenericBinding( _key ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RebindPlayableGraphOutputs(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RebindPlayableGraphOutputs( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_state(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.state); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_extrapolationMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.extrapolationMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_playableAsset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.playableAsset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_playableGraph(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.playableGraph); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_playOnAwake(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.playOnAwake); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_timeUpdateMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.timeUpdateMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_time(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.time); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_initialTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.initialTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_duration(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.duration); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_extrapolationMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + UnityEngine.Playables.DirectorWrapMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.extrapolationMode = 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_playableAsset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.playableAsset = (UnityEngine.Playables.PlayableAsset)translator.GetObject(L, 2, typeof(UnityEngine.Playables.PlayableAsset)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_playOnAwake(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.playOnAwake = 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_timeUpdateMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + UnityEngine.Playables.DirectorUpdateMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.timeUpdateMode = 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_time(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.time = 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_initialTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.initialTime = 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 _e_played(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.played += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.played -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Playables.PlayableDirector.played!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_paused(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.paused += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.paused -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Playables.PlayableDirector.paused!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_stopped(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + UnityEngine.Playables.PlayableDirector gen_to_be_invoked = (UnityEngine.Playables.PlayableDirector)translator.FastGetCSObj(L, 1); + System.Action gen_delegate = translator.GetDelegate>(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need System.Action!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.stopped += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.stopped -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Playables.PlayableDirector.stopped!"); + return 0; + } + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_Playables_PlayableWrap.cs b/Assets/XLua/Gen/UnityEngine_Playables_PlayableWrap.cs new file mode 100644 index 000000000..a12939ea6 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_Playables_PlayableWrap.cs @@ -0,0 +1,233 @@ +#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 UnityEnginePlayablesPlayableWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Playables.Playable); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHandle", _m_GetHandle); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPlayableType", _m_GetPlayableType); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Equals", _m_Equals); + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 1, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Create", _m_Create_xlua_st_); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "Null", _g_get_Null); + + + + 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) + { + translator.Push(L, default(UnityEngine.Playables.Playable)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Playables.Playable constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Create_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + UnityEngine.Playables.PlayableGraph _graph;translator.Get(L, 1, out _graph); + int _inputCount = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = UnityEngine.Playables.Playable.Create( _graph, _inputCount ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + UnityEngine.Playables.PlayableGraph _graph;translator.Get(L, 1, out _graph); + + var gen_ret = UnityEngine.Playables.Playable.Create( _graph ); + 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 UnityEngine.Playables.Playable.Create!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetHandle(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Playables.Playable gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.GetHandle( ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetPlayableType(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Playables.Playable gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.GetPlayableType( ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Equals(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Playables.Playable gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.Playables.Playable _other;translator.Get(L, 2, out _other); + + var gen_ret = gen_to_be_invoked.Equals( _other ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Null(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Playables.Playable.Null); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_PlayerPrefsWrap.cs b/Assets/XLua/Gen/UnityEngine_PlayerPrefsWrap.cs new file mode 100644 index 000000000..f4a3d283a --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_PlayerPrefsWrap.cs @@ -0,0 +1,387 @@ +#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 UnityEnginePlayerPrefsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.PlayerPrefs); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 11, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetInt", _m_SetInt_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetInt", _m_GetInt_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetFloat", _m_SetFloat_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetFloat", _m_GetFloat_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetString", _m_SetString_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetString", _m_GetString_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "HasKey", _m_HasKey_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "DeleteKey", _m_DeleteKey_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "DeleteAll", _m_DeleteAll_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Save", _m_Save_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 UnityEngine.PlayerPrefs(); + 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 UnityEngine.PlayerPrefs constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetInt_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _key = LuaAPI.lua_tostring(L, 1); + int _value = LuaAPI.xlua_tointeger(L, 2); + + UnityEngine.PlayerPrefs.SetInt( _key, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetInt_xlua_st_(RealStatePtr L) + { + try { + + + + 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 _key = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.PlayerPrefs.GetInt( _key ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + string _key = LuaAPI.lua_tostring(L, 1); + int _defaultValue = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = UnityEngine.PlayerPrefs.GetInt( _key, _defaultValue ); + LuaAPI.xlua_pushinteger(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 UnityEngine.PlayerPrefs.GetInt!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetFloat_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _key = LuaAPI.lua_tostring(L, 1); + float _value = (float)LuaAPI.lua_tonumber(L, 2); + + UnityEngine.PlayerPrefs.SetFloat( _key, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetFloat_xlua_st_(RealStatePtr L) + { + try { + + + + 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 _key = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.PlayerPrefs.GetFloat( _key ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + string _key = LuaAPI.lua_tostring(L, 1); + float _defaultValue = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = UnityEngine.PlayerPrefs.GetFloat( _key, _defaultValue ); + LuaAPI.lua_pushnumber(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 UnityEngine.PlayerPrefs.GetFloat!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetString_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _key = LuaAPI.lua_tostring(L, 1); + string _value = LuaAPI.lua_tostring(L, 2); + + UnityEngine.PlayerPrefs.SetString( _key, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetString_xlua_st_(RealStatePtr L) + { + try { + + + + 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 _key = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.PlayerPrefs.GetString( _key ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _key = LuaAPI.lua_tostring(L, 1); + string _defaultValue = LuaAPI.lua_tostring(L, 2); + + var gen_ret = UnityEngine.PlayerPrefs.GetString( _key, _defaultValue ); + LuaAPI.lua_pushstring(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 UnityEngine.PlayerPrefs.GetString!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasKey_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _key = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.PlayerPrefs.HasKey( _key ); + 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_DeleteKey_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _key = LuaAPI.lua_tostring(L, 1); + + UnityEngine.PlayerPrefs.DeleteKey( _key ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DeleteAll_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + UnityEngine.PlayerPrefs.DeleteAll( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Save_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + UnityEngine.PlayerPrefs.Save( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_Purchasing_ProductDefinitionWrap.cs b/Assets/XLua/Gen/UnityEngine_Purchasing_ProductDefinitionWrap.cs new file mode 100644 index 000000000..57c9f2a4e --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_Purchasing_ProductDefinitionWrap.cs @@ -0,0 +1,284 @@ +#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 UnityEnginePurchasingProductDefinitionWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Purchasing.ProductDefinition); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 6, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Equals", _m_Equals); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashCode", _m_GetHashCode); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "id", _g_get_id); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "storeSpecificId", _g_get_storeSpecificId); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "type", _g_get_type); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enabled", _g_get_enabled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "payouts", _g_get_payouts); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "payout", _g_get_payout); + + + + 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) == 4 && (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) && translator.Assignable(L, 4)) + { + string _id = LuaAPI.lua_tostring(L, 2); + string _storeSpecificId = LuaAPI.lua_tostring(L, 3); + UnityEngine.Purchasing.ProductType _type;translator.Get(L, 4, out _type); + + var gen_ret = new UnityEngine.Purchasing.ProductDefinition(_id, _storeSpecificId, _type); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 5 && (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) && translator.Assignable(L, 4) && LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)) + { + string _id = LuaAPI.lua_tostring(L, 2); + string _storeSpecificId = LuaAPI.lua_tostring(L, 3); + UnityEngine.Purchasing.ProductType _type;translator.Get(L, 4, out _type); + bool _enabled = LuaAPI.lua_toboolean(L, 5); + + var gen_ret = new UnityEngine.Purchasing.ProductDefinition(_id, _storeSpecificId, _type, _enabled); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 6 && (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) && translator.Assignable(L, 4) && LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5) && translator.Assignable(L, 6)) + { + string _id = LuaAPI.lua_tostring(L, 2); + string _storeSpecificId = LuaAPI.lua_tostring(L, 3); + UnityEngine.Purchasing.ProductType _type;translator.Get(L, 4, out _type); + bool _enabled = LuaAPI.lua_toboolean(L, 5); + UnityEngine.Purchasing.PayoutDefinition _payout = (UnityEngine.Purchasing.PayoutDefinition)translator.GetObject(L, 6, typeof(UnityEngine.Purchasing.PayoutDefinition)); + + var gen_ret = new UnityEngine.Purchasing.ProductDefinition(_id, _storeSpecificId, _type, _enabled, _payout); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 6 && (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) && translator.Assignable(L, 4) && LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5) && translator.Assignable>(L, 6)) + { + string _id = LuaAPI.lua_tostring(L, 2); + string _storeSpecificId = LuaAPI.lua_tostring(L, 3); + UnityEngine.Purchasing.ProductType _type;translator.Get(L, 4, out _type); + bool _enabled = LuaAPI.lua_toboolean(L, 5); + System.Collections.Generic.IEnumerable _payouts = (System.Collections.Generic.IEnumerable)translator.GetObject(L, 6, typeof(System.Collections.Generic.IEnumerable)); + + var gen_ret = new UnityEngine.Purchasing.ProductDefinition(_id, _storeSpecificId, _type, _enabled, _payouts); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 3 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING) && translator.Assignable(L, 3)) + { + string _id = LuaAPI.lua_tostring(L, 2); + UnityEngine.Purchasing.ProductType _type;translator.Get(L, 3, out _type); + + var gen_ret = new UnityEngine.Purchasing.ProductDefinition(_id, _type); + 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 UnityEngine.Purchasing.ProductDefinition constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Equals(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Purchasing.ProductDefinition gen_to_be_invoked = (UnityEngine.Purchasing.ProductDefinition)translator.FastGetCSObj(L, 1); + + + + { + object _obj = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.Equals( _obj ); + 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_GetHashCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Purchasing.ProductDefinition gen_to_be_invoked = (UnityEngine.Purchasing.ProductDefinition)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetHashCode( ); + 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 _g_get_id(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Purchasing.ProductDefinition gen_to_be_invoked = (UnityEngine.Purchasing.ProductDefinition)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.id); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_storeSpecificId(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Purchasing.ProductDefinition gen_to_be_invoked = (UnityEngine.Purchasing.ProductDefinition)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.storeSpecificId); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_type(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Purchasing.ProductDefinition gen_to_be_invoked = (UnityEngine.Purchasing.ProductDefinition)translator.FastGetCSObj(L, 1); + translator.PushUnityEnginePurchasingProductType(L, gen_to_be_invoked.type); + } 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); + + UnityEngine.Purchasing.ProductDefinition gen_to_be_invoked = (UnityEngine.Purchasing.ProductDefinition)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_payouts(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Purchasing.ProductDefinition gen_to_be_invoked = (UnityEngine.Purchasing.ProductDefinition)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.payouts); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_payout(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Purchasing.ProductDefinition gen_to_be_invoked = (UnityEngine.Purchasing.ProductDefinition)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.payout); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_Purchasing_ProductMetadataWrap.cs b/Assets/XLua/Gen/UnityEngine_Purchasing_ProductMetadataWrap.cs new file mode 100644 index 000000000..ee1627552 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_Purchasing_ProductMetadataWrap.cs @@ -0,0 +1,181 @@ +#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 UnityEnginePurchasingProductMetadataWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Purchasing.ProductMetadata); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 5, 0); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "localizedPriceString", _g_get_localizedPriceString); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "localizedTitle", _g_get_localizedTitle); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "localizedDescription", _g_get_localizedDescription); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isoCurrencyCode", _g_get_isoCurrencyCode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "localizedPrice", _g_get_localizedPrice); + + + + 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) == 6 && (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) && (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING) && (LuaAPI.lua_isnil(L, 5) || LuaAPI.lua_type(L, 5) == LuaTypes.LUA_TSTRING) && (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6) || translator.IsDecimal(L, 6))) + { + string _priceString = LuaAPI.lua_tostring(L, 2); + string _title = LuaAPI.lua_tostring(L, 3); + string _description = LuaAPI.lua_tostring(L, 4); + string _currencyCode = LuaAPI.lua_tostring(L, 5); + decimal _localizedPrice;translator.Get(L, 6, out _localizedPrice); + + var gen_ret = new UnityEngine.Purchasing.ProductMetadata(_priceString, _title, _description, _currencyCode, _localizedPrice); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && translator.Assignable(L, 2)) + { + UnityEngine.Purchasing.ProductMetadata _productMetadata = (UnityEngine.Purchasing.ProductMetadata)translator.GetObject(L, 2, typeof(UnityEngine.Purchasing.ProductMetadata)); + + var gen_ret = new UnityEngine.Purchasing.ProductMetadata(_productMetadata); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new UnityEngine.Purchasing.ProductMetadata(); + 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 UnityEngine.Purchasing.ProductMetadata constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_localizedPriceString(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Purchasing.ProductMetadata gen_to_be_invoked = (UnityEngine.Purchasing.ProductMetadata)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.localizedPriceString); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_localizedTitle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Purchasing.ProductMetadata gen_to_be_invoked = (UnityEngine.Purchasing.ProductMetadata)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.localizedTitle); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_localizedDescription(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Purchasing.ProductMetadata gen_to_be_invoked = (UnityEngine.Purchasing.ProductMetadata)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.localizedDescription); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isoCurrencyCode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Purchasing.ProductMetadata gen_to_be_invoked = (UnityEngine.Purchasing.ProductMetadata)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.isoCurrencyCode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_localizedPrice(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Purchasing.ProductMetadata gen_to_be_invoked = (UnityEngine.Purchasing.ProductMetadata)translator.FastGetCSObj(L, 1); + translator.PushDecimal(L, gen_to_be_invoked.localizedPrice); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_Purchasing_ProductWrap.cs b/Assets/XLua/Gen/UnityEngine_Purchasing_ProductWrap.cs new file mode 100644 index 000000000..bf666f447 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_Purchasing_ProductWrap.cs @@ -0,0 +1,246 @@ +#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 UnityEnginePurchasingProductWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Purchasing.Product); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 8, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Equals", _m_Equals); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashCode", _m_GetHashCode); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "definition", _g_get_definition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "metadata", _g_get_metadata); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "availableToPurchase", _g_get_availableToPurchase); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "transactionID", _g_get_transactionID); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "appleOriginalTransactionID", _g_get_appleOriginalTransactionID); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "appleProductIsRestored", _g_get_appleProductIsRestored); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "hasReceipt", _g_get_hasReceipt); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "receipt", _g_get_receipt); + + + + 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, "UnityEngine.Purchasing.Product does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Equals(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Purchasing.Product gen_to_be_invoked = (UnityEngine.Purchasing.Product)translator.FastGetCSObj(L, 1); + + + + { + object _obj = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.Equals( _obj ); + 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_GetHashCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Purchasing.Product gen_to_be_invoked = (UnityEngine.Purchasing.Product)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetHashCode( ); + 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 _g_get_definition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Purchasing.Product gen_to_be_invoked = (UnityEngine.Purchasing.Product)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.definition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_metadata(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Purchasing.Product gen_to_be_invoked = (UnityEngine.Purchasing.Product)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.metadata); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_availableToPurchase(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Purchasing.Product gen_to_be_invoked = (UnityEngine.Purchasing.Product)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.availableToPurchase); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_transactionID(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Purchasing.Product gen_to_be_invoked = (UnityEngine.Purchasing.Product)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.transactionID); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_appleOriginalTransactionID(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Purchasing.Product gen_to_be_invoked = (UnityEngine.Purchasing.Product)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.appleOriginalTransactionID); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_appleProductIsRestored(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Purchasing.Product gen_to_be_invoked = (UnityEngine.Purchasing.Product)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.appleProductIsRestored); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_hasReceipt(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Purchasing.Product gen_to_be_invoked = (UnityEngine.Purchasing.Product)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hasReceipt); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_receipt(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Purchasing.Product gen_to_be_invoked = (UnityEngine.Purchasing.Product)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.receipt); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_Purchasing_Security_AppleStoreKitTestTangleWrap.cs b/Assets/XLua/Gen/UnityEngine_Purchasing_Security_AppleStoreKitTestTangleWrap.cs new file mode 100644 index 000000000..b6bdb889b --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_Purchasing_Security_AppleStoreKitTestTangleWrap.cs @@ -0,0 +1,110 @@ +#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 UnityEnginePurchasingSecurityAppleStoreKitTestTangleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Purchasing.Security.AppleStoreKitTestTangle); + 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, "Data", _m_Data_xlua_st_); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IsPopulated", UnityEngine.Purchasing.Security.AppleStoreKitTestTangle.IsPopulated); + + + + + 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 UnityEngine.Purchasing.Security.AppleStoreKitTestTangle(); + 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 UnityEngine.Purchasing.Security.AppleStoreKitTestTangle constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Data_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = UnityEngine.Purchasing.Security.AppleStoreKitTestTangle.Data( ); + 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/UnityEngine_Purchasing_Security_AppleTangleWrap.cs b/Assets/XLua/Gen/UnityEngine_Purchasing_Security_AppleTangleWrap.cs new file mode 100644 index 000000000..9cf6cfea5 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_Purchasing_Security_AppleTangleWrap.cs @@ -0,0 +1,110 @@ +#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 UnityEnginePurchasingSecurityAppleTangleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Purchasing.Security.AppleTangle); + 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, "Data", _m_Data_xlua_st_); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IsPopulated", UnityEngine.Purchasing.Security.AppleTangle.IsPopulated); + + + + + 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 UnityEngine.Purchasing.Security.AppleTangle(); + 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 UnityEngine.Purchasing.Security.AppleTangle constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Data_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = UnityEngine.Purchasing.Security.AppleTangle.Data( ); + 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/UnityEngine_Purchasing_Security_GooglePlayTangleWrap.cs b/Assets/XLua/Gen/UnityEngine_Purchasing_Security_GooglePlayTangleWrap.cs new file mode 100644 index 000000000..0e9edb4a3 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_Purchasing_Security_GooglePlayTangleWrap.cs @@ -0,0 +1,110 @@ +#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 UnityEnginePurchasingSecurityGooglePlayTangleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Purchasing.Security.GooglePlayTangle); + 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, "Data", _m_Data_xlua_st_); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IsPopulated", UnityEngine.Purchasing.Security.GooglePlayTangle.IsPopulated); + + + + + 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 UnityEngine.Purchasing.Security.GooglePlayTangle(); + 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 UnityEngine.Purchasing.Security.GooglePlayTangle constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Data_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = UnityEngine.Purchasing.Security.GooglePlayTangle.Data( ); + 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/UnityEngine_QuaternionWrap.cs b/Assets/XLua/Gen/UnityEngine_QuaternionWrap.cs new file mode 100644 index 000000000..5532a358f --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_QuaternionWrap.cs @@ -0,0 +1,1138 @@ +#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 UnityEngineQuaternionWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Quaternion); + Utils.BeginObjectRegister(type, L, translator, 2, 8, 6, 5); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__mul", __MulMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__eq", __EqMeta); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Set", _m_Set); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLookRotation", _m_SetLookRotation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToAngleAxis", _m_ToAngleAxis); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetFromToRotation", _m_SetFromToRotation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Normalize", _m_Normalize); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashCode", _m_GetHashCode); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Equals", _m_Equals); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "eulerAngles", _g_get_eulerAngles); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "normalized", _g_get_normalized); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "x", _g_get_x); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "y", _g_get_y); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "z", _g_get_z); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "w", _g_get_w); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "eulerAngles", _s_set_eulerAngles); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "x", _s_set_x); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "y", _s_set_y); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "z", _s_set_z); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "w", _s_set_w); + + + Utils.EndObjectRegister(type, L, translator, __CSIndexer, __NewIndexer, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 15, 1, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Dot", _m_Dot_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Angle", _m_Angle_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Euler", _m_Euler_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RotateTowards", _m_RotateTowards_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Normalize", _m_Normalize_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FromToRotation", _m_FromToRotation_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Inverse", _m_Inverse_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Slerp", _m_Slerp_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SlerpUnclamped", _m_SlerpUnclamped_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Lerp", _m_Lerp_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LerpUnclamped", _m_LerpUnclamped_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "AngleAxis", _m_AngleAxis_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LookRotation", _m_LookRotation_xlua_st_); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "kEpsilon", UnityEngine.Quaternion.kEpsilon); + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "identity", _g_get_identity); + + + + 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) == 5 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + float _w = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = new UnityEngine.Quaternion(_x, _y, _z, _w); + translator.PushUnityEngineQuaternion(L, gen_ret); + + return 1; + } + + if (LuaAPI.lua_gettop(L) == 1) + { + translator.PushUnityEngineQuaternion(L, default(UnityEngine.Quaternion)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Quaternion constructor!"); + + } + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __CSIndexer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + if (translator.Assignable(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + + UnityEngine.Quaternion gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + int index = LuaAPI.xlua_tointeger(L, 2); + LuaAPI.lua_pushboolean(L, true); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked[index]); + return 2; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __NewIndexer(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + try { + + if (translator.Assignable(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + + UnityEngine.Quaternion gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + int key = LuaAPI.xlua_tointeger(L, 2); + gen_to_be_invoked[key] = (float)LuaAPI.lua_tonumber(L, 3); + LuaAPI.lua_pushboolean(L, true); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __MulMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + UnityEngine.Quaternion leftside;translator.Get(L, 1, out leftside); + UnityEngine.Quaternion rightside;translator.Get(L, 2, out rightside); + + translator.PushUnityEngineQuaternion(L, leftside * rightside); + + return 1; + } + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + UnityEngine.Quaternion leftside;translator.Get(L, 1, out leftside); + UnityEngine.Vector3 rightside;translator.Get(L, 2, out rightside); + + translator.PushUnityEngineVector3(L, leftside * rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of * operator, need UnityEngine.Quaternion!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __EqMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + UnityEngine.Quaternion leftside;translator.Get(L, 1, out leftside); + UnityEngine.Quaternion rightside;translator.Get(L, 2, out rightside); + + LuaAPI.lua_pushboolean(L, leftside == rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of == operator, need UnityEngine.Quaternion!"); + + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Set(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Quaternion gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + float _newX = (float)LuaAPI.lua_tonumber(L, 2); + float _newY = (float)LuaAPI.lua_tonumber(L, 3); + float _newZ = (float)LuaAPI.lua_tonumber(L, 4); + float _newW = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.Set( _newX, _newY, _newZ, _newW ); + + + translator.UpdateUnityEngineQuaternion(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Dot_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Quaternion _a;translator.Get(L, 1, out _a); + UnityEngine.Quaternion _b;translator.Get(L, 2, out _b); + + var gen_ret = UnityEngine.Quaternion.Dot( _a, _b ); + LuaAPI.lua_pushnumber(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_SetLookRotation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Quaternion gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _view;translator.Get(L, 2, out _view); + + gen_to_be_invoked.SetLookRotation( _view ); + + + translator.UpdateUnityEngineQuaternion(L, 1, gen_to_be_invoked); + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _view;translator.Get(L, 2, out _view); + UnityEngine.Vector3 _up;translator.Get(L, 3, out _up); + + gen_to_be_invoked.SetLookRotation( _view, _up ); + + + translator.UpdateUnityEngineQuaternion(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Quaternion.SetLookRotation!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Angle_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Quaternion _a;translator.Get(L, 1, out _a); + UnityEngine.Quaternion _b;translator.Get(L, 2, out _b); + + var gen_ret = UnityEngine.Quaternion.Angle( _a, _b ); + LuaAPI.lua_pushnumber(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_Euler_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _x = (float)LuaAPI.lua_tonumber(L, 1); + float _y = (float)LuaAPI.lua_tonumber(L, 2); + float _z = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Quaternion.Euler( _x, _y, _z ); + translator.PushUnityEngineQuaternion(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + UnityEngine.Vector3 _euler;translator.Get(L, 1, out _euler); + + var gen_ret = UnityEngine.Quaternion.Euler( _euler ); + translator.PushUnityEngineQuaternion(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 UnityEngine.Quaternion.Euler!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToAngleAxis(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Quaternion gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + float _angle; + UnityEngine.Vector3 _axis; + + gen_to_be_invoked.ToAngleAxis( out _angle, out _axis ); + LuaAPI.lua_pushnumber(L, _angle); + + translator.PushUnityEngineVector3(L, _axis); + + + + translator.UpdateUnityEngineQuaternion(L, 1, gen_to_be_invoked); + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetFromToRotation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Quaternion gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.Vector3 _fromDirection;translator.Get(L, 2, out _fromDirection); + UnityEngine.Vector3 _toDirection;translator.Get(L, 3, out _toDirection); + + gen_to_be_invoked.SetFromToRotation( _fromDirection, _toDirection ); + + + translator.UpdateUnityEngineQuaternion(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RotateTowards_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Quaternion _from;translator.Get(L, 1, out _from); + UnityEngine.Quaternion _to;translator.Get(L, 2, out _to); + float _maxDegreesDelta = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Quaternion.RotateTowards( _from, _to, _maxDegreesDelta ); + translator.PushUnityEngineQuaternion(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_Normalize_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Quaternion _q;translator.Get(L, 1, out _q); + + var gen_ret = UnityEngine.Quaternion.Normalize( _q ); + translator.PushUnityEngineQuaternion(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_Normalize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Quaternion gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + gen_to_be_invoked.Normalize( ); + + + translator.UpdateUnityEngineQuaternion(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetHashCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Quaternion gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.GetHashCode( ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + translator.UpdateUnityEngineQuaternion(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Equals(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Quaternion gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _other = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.Equals( _other ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.UpdateUnityEngineQuaternion(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Quaternion _other;translator.Get(L, 2, out _other); + + var gen_ret = gen_to_be_invoked.Equals( _other ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.UpdateUnityEngineQuaternion(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Quaternion.Equals!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Quaternion gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.ToString( ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.UpdateUnityEngineQuaternion(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _format = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.ToString( _format ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.UpdateUnityEngineQuaternion(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _format = LuaAPI.lua_tostring(L, 2); + System.IFormatProvider _formatProvider = (System.IFormatProvider)translator.GetObject(L, 3, typeof(System.IFormatProvider)); + + var gen_ret = gen_to_be_invoked.ToString( _format, _formatProvider ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.UpdateUnityEngineQuaternion(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Quaternion.ToString!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FromToRotation_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector3 _fromDirection;translator.Get(L, 1, out _fromDirection); + UnityEngine.Vector3 _toDirection;translator.Get(L, 2, out _toDirection); + + var gen_ret = UnityEngine.Quaternion.FromToRotation( _fromDirection, _toDirection ); + translator.PushUnityEngineQuaternion(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_Inverse_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Quaternion _rotation;translator.Get(L, 1, out _rotation); + + var gen_ret = UnityEngine.Quaternion.Inverse( _rotation ); + translator.PushUnityEngineQuaternion(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_Slerp_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Quaternion _a;translator.Get(L, 1, out _a); + UnityEngine.Quaternion _b;translator.Get(L, 2, out _b); + float _t = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Quaternion.Slerp( _a, _b, _t ); + translator.PushUnityEngineQuaternion(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_SlerpUnclamped_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Quaternion _a;translator.Get(L, 1, out _a); + UnityEngine.Quaternion _b;translator.Get(L, 2, out _b); + float _t = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Quaternion.SlerpUnclamped( _a, _b, _t ); + translator.PushUnityEngineQuaternion(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_Lerp_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Quaternion _a;translator.Get(L, 1, out _a); + UnityEngine.Quaternion _b;translator.Get(L, 2, out _b); + float _t = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Quaternion.Lerp( _a, _b, _t ); + translator.PushUnityEngineQuaternion(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_LerpUnclamped_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Quaternion _a;translator.Get(L, 1, out _a); + UnityEngine.Quaternion _b;translator.Get(L, 2, out _b); + float _t = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Quaternion.LerpUnclamped( _a, _b, _t ); + translator.PushUnityEngineQuaternion(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_AngleAxis_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + float _angle = (float)LuaAPI.lua_tonumber(L, 1); + UnityEngine.Vector3 _axis;translator.Get(L, 2, out _axis); + + var gen_ret = UnityEngine.Quaternion.AngleAxis( _angle, _axis ); + translator.PushUnityEngineQuaternion(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_LookRotation_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + UnityEngine.Vector3 _forward;translator.Get(L, 1, out _forward); + + var gen_ret = UnityEngine.Quaternion.LookRotation( _forward ); + translator.PushUnityEngineQuaternion(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _forward;translator.Get(L, 1, out _forward); + UnityEngine.Vector3 _upwards;translator.Get(L, 2, out _upwards); + + var gen_ret = UnityEngine.Quaternion.LookRotation( _forward, _upwards ); + translator.PushUnityEngineQuaternion(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 UnityEngine.Quaternion.LookRotation!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_identity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineQuaternion(L, UnityEngine.Quaternion.identity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_eulerAngles(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Quaternion gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.eulerAngles); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_normalized(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Quaternion gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineQuaternion(L, gen_to_be_invoked.normalized); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_x(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Quaternion gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.x); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_y(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Quaternion gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.y); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_z(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Quaternion gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.z); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_w(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Quaternion gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.w); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_eulerAngles(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Quaternion gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.eulerAngles = gen_value; + + translator.UpdateUnityEngineQuaternion(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_x(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Quaternion gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.x = (float)LuaAPI.lua_tonumber(L, 2); + + translator.UpdateUnityEngineQuaternion(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_y(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Quaternion gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.y = (float)LuaAPI.lua_tonumber(L, 2); + + translator.UpdateUnityEngineQuaternion(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_z(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Quaternion gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.z = (float)LuaAPI.lua_tonumber(L, 2); + + translator.UpdateUnityEngineQuaternion(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_w(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Quaternion gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.w = (float)LuaAPI.lua_tonumber(L, 2); + + translator.UpdateUnityEngineQuaternion(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_Ray2DWrap.cs b/Assets/XLua/Gen/UnityEngine_Ray2DWrap.cs new file mode 100644 index 000000000..1a05fd540 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_Ray2DWrap.cs @@ -0,0 +1,254 @@ +#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 UnityEngineRay2DWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Ray2D); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 2, 2); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPoint", _m_GetPoint); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "origin", _g_get_origin); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "direction", _g_get_direction); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "origin", _s_set_origin); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "direction", _s_set_direction); + + + 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 && translator.Assignable(L, 2) && translator.Assignable(L, 3)) + { + UnityEngine.Vector2 _origin;translator.Get(L, 2, out _origin); + UnityEngine.Vector2 _direction;translator.Get(L, 3, out _direction); + + var gen_ret = new UnityEngine.Ray2D(_origin, _direction); + translator.PushUnityEngineRay2D(L, gen_ret); + + return 1; + } + + if (LuaAPI.lua_gettop(L) == 1) + { + translator.PushUnityEngineRay2D(L, default(UnityEngine.Ray2D)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Ray2D constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetPoint(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Ray2D gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + float _distance = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.GetPoint( _distance ); + translator.PushUnityEngineVector2(L, gen_ret); + + + translator.UpdateUnityEngineRay2D(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Ray2D gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.ToString( ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.UpdateUnityEngineRay2D(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _format = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.ToString( _format ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.UpdateUnityEngineRay2D(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _format = LuaAPI.lua_tostring(L, 2); + System.IFormatProvider _formatProvider = (System.IFormatProvider)translator.GetObject(L, 3, typeof(System.IFormatProvider)); + + var gen_ret = gen_to_be_invoked.ToString( _format, _formatProvider ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.UpdateUnityEngineRay2D(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Ray2D.ToString!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_origin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Ray2D gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.origin); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_direction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Ray2D gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.direction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_origin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Ray2D gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.origin = gen_value; + + translator.UpdateUnityEngineRay2D(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_direction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Ray2D gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.direction = gen_value; + + translator.UpdateUnityEngineRay2D(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_RayWrap.cs b/Assets/XLua/Gen/UnityEngine_RayWrap.cs new file mode 100644 index 000000000..b89cf9d94 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_RayWrap.cs @@ -0,0 +1,254 @@ +#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 UnityEngineRayWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Ray); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 2, 2); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPoint", _m_GetPoint); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "origin", _g_get_origin); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "direction", _g_get_direction); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "origin", _s_set_origin); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "direction", _s_set_direction); + + + 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 && translator.Assignable(L, 2) && translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _origin;translator.Get(L, 2, out _origin); + UnityEngine.Vector3 _direction;translator.Get(L, 3, out _direction); + + var gen_ret = new UnityEngine.Ray(_origin, _direction); + translator.PushUnityEngineRay(L, gen_ret); + + return 1; + } + + if (LuaAPI.lua_gettop(L) == 1) + { + translator.PushUnityEngineRay(L, default(UnityEngine.Ray)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Ray constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetPoint(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Ray gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + float _distance = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.GetPoint( _distance ); + translator.PushUnityEngineVector3(L, gen_ret); + + + translator.UpdateUnityEngineRay(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Ray gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.ToString( ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.UpdateUnityEngineRay(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _format = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.ToString( _format ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.UpdateUnityEngineRay(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _format = LuaAPI.lua_tostring(L, 2); + System.IFormatProvider _formatProvider = (System.IFormatProvider)translator.GetObject(L, 3, typeof(System.IFormatProvider)); + + var gen_ret = gen_to_be_invoked.ToString( _format, _formatProvider ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.UpdateUnityEngineRay(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Ray.ToString!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_origin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Ray gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.origin); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_direction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Ray gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.direction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_origin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Ray gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.origin = gen_value; + + translator.UpdateUnityEngineRay(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_direction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Ray gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.direction = gen_value; + + translator.UpdateUnityEngineRay(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_RaycastHitWrap.cs b/Assets/XLua/Gen/UnityEngine_RaycastHitWrap.cs new file mode 100644 index 000000000..6f4d59f11 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_RaycastHitWrap.cs @@ -0,0 +1,352 @@ +#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 UnityEngineRaycastHitWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.RaycastHit); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 13, 4); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "collider", _g_get_collider); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "colliderInstanceID", _g_get_colliderInstanceID); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "point", _g_get_point); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "normal", _g_get_normal); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "barycentricCoordinate", _g_get_barycentricCoordinate); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "distance", _g_get_distance); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "triangleIndex", _g_get_triangleIndex); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "textureCoord", _g_get_textureCoord); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "textureCoord2", _g_get_textureCoord2); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "transform", _g_get_transform); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rigidbody", _g_get_rigidbody); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "articulationBody", _g_get_articulationBody); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lightmapCoord", _g_get_lightmapCoord); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "point", _s_set_point); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "normal", _s_set_normal); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "barycentricCoordinate", _s_set_barycentricCoordinate); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "distance", _s_set_distance); + + + 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) + { + translator.Push(L, default(UnityEngine.RaycastHit)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.RaycastHit constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_collider(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RaycastHit gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.collider); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_colliderInstanceID(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RaycastHit gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.colliderInstanceID); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_point(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RaycastHit gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.point); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_normal(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RaycastHit gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.normal); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_barycentricCoordinate(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RaycastHit gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.barycentricCoordinate); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_distance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RaycastHit gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.distance); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_triangleIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RaycastHit gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.triangleIndex); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_textureCoord(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RaycastHit gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.textureCoord); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_textureCoord2(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RaycastHit gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.textureCoord2); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_transform(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RaycastHit gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.transform); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rigidbody(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RaycastHit gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.rigidbody); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_articulationBody(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RaycastHit gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.articulationBody); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lightmapCoord(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RaycastHit gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.lightmapCoord); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_point(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RaycastHit gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.point = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_normal(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RaycastHit gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.normal = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_barycentricCoordinate(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RaycastHit gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.barycentricCoordinate = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_distance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RaycastHit gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.distance = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_RectTransformWrap.cs b/Assets/XLua/Gen/UnityEngine_RectTransformWrap.cs new file mode 100644 index 000000000..b34f6e5d8 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_RectTransformWrap.cs @@ -0,0 +1,1423 @@ +#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; +using DG.Tweening; + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class UnityEngineRectTransformWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.RectTransform); + Utils.BeginObjectRegister(type, L, translator, 0, 21, 10, 8); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ForceUpdateRectTransforms", _m_ForceUpdateRectTransforms); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetLocalCorners", _m_GetLocalCorners); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetWorldCorners", _m_GetWorldCorners); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetInsetAndSizeFromParentEdge", _m_SetInsetAndSizeFromParentEdge); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSizeWithCurrentAnchors", _m_SetSizeWithCurrentAnchors); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOAnchorPos", _m_DOAnchorPos); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOAnchorPosX", _m_DOAnchorPosX); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOAnchorPosY", _m_DOAnchorPosY); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOAnchorPos3D", _m_DOAnchorPos3D); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOAnchorPos3DX", _m_DOAnchorPos3DX); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOAnchorPos3DY", _m_DOAnchorPos3DY); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOAnchorPos3DZ", _m_DOAnchorPos3DZ); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOAnchorMax", _m_DOAnchorMax); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOAnchorMin", _m_DOAnchorMin); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOPivot", _m_DOPivot); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOPivotX", _m_DOPivotX); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOPivotY", _m_DOPivotY); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOSizeDelta", _m_DOSizeDelta); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOPunchAnchorPos", _m_DOPunchAnchorPos); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOShakeAnchorPos", _m_DOShakeAnchorPos); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOJumpAnchorPos", _m_DOJumpAnchorPos); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rect", _g_get_rect); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "anchorMin", _g_get_anchorMin); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "anchorMax", _g_get_anchorMax); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "anchoredPosition", _g_get_anchoredPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sizeDelta", _g_get_sizeDelta); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "pivot", _g_get_pivot); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "anchoredPosition3D", _g_get_anchoredPosition3D); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "offsetMin", _g_get_offsetMin); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "offsetMax", _g_get_offsetMax); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "drivenByObject", _g_get_drivenByObject); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "anchorMin", _s_set_anchorMin); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "anchorMax", _s_set_anchorMax); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "anchoredPosition", _s_set_anchoredPosition); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sizeDelta", _s_set_sizeDelta); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "pivot", _s_set_pivot); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "anchoredPosition3D", _s_set_anchoredPosition3D); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "offsetMin", _s_set_offsetMin); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "offsetMax", _s_set_offsetMax); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + + Utils.RegisterFunc(L, Utils.CLS_IDX, "reapplyDrivenProperties", _e_reapplyDrivenProperties); + + + + + + 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 UnityEngine.RectTransform(); + 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 UnityEngine.RectTransform constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ForceUpdateRectTransforms(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ForceUpdateRectTransforms( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetLocalCorners(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector3[] _fourCornersArray = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + + gen_to_be_invoked.GetLocalCorners( _fourCornersArray ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetWorldCorners(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector3[] _fourCornersArray = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + + gen_to_be_invoked.GetWorldCorners( _fourCornersArray ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetInsetAndSizeFromParentEdge(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.RectTransform.Edge _edge;translator.Get(L, 2, out _edge); + float _inset = (float)LuaAPI.lua_tonumber(L, 3); + float _size = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.SetInsetAndSizeFromParentEdge( _edge, _inset, _size ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSizeWithCurrentAnchors(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.RectTransform.Axis _axis;translator.Get(L, 2, out _axis); + float _size = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetSizeWithCurrentAnchors( _axis, _size ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOAnchorPos(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector2 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapping = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.DOAnchorPos( _endValue, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector2 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOAnchorPos( _endValue, _duration ); + 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 UnityEngine.RectTransform.DOAnchorPos!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOAnchorPosX(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapping = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.DOAnchorPosX( _endValue, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOAnchorPosX( _endValue, _duration ); + 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 UnityEngine.RectTransform.DOAnchorPosX!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOAnchorPosY(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapping = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.DOAnchorPosY( _endValue, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOAnchorPosY( _endValue, _duration ); + 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 UnityEngine.RectTransform.DOAnchorPosY!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOAnchorPos3D(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapping = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.DOAnchorPos3D( _endValue, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOAnchorPos3D( _endValue, _duration ); + 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 UnityEngine.RectTransform.DOAnchorPos3D!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOAnchorPos3DX(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapping = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.DOAnchorPos3DX( _endValue, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOAnchorPos3DX( _endValue, _duration ); + 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 UnityEngine.RectTransform.DOAnchorPos3DX!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOAnchorPos3DY(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapping = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.DOAnchorPos3DY( _endValue, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOAnchorPos3DY( _endValue, _duration ); + 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 UnityEngine.RectTransform.DOAnchorPos3DY!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOAnchorPos3DZ(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapping = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.DOAnchorPos3DZ( _endValue, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOAnchorPos3DZ( _endValue, _duration ); + 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 UnityEngine.RectTransform.DOAnchorPos3DZ!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOAnchorMax(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector2 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapping = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.DOAnchorMax( _endValue, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector2 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOAnchorMax( _endValue, _duration ); + 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 UnityEngine.RectTransform.DOAnchorMax!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOAnchorMin(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector2 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapping = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.DOAnchorMin( _endValue, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector2 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOAnchorMin( _endValue, _duration ); + 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 UnityEngine.RectTransform.DOAnchorMin!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOPivot(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector2 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOPivot( _endValue, _duration ); + 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_DOPivotX(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + + + + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOPivotX( _endValue, _duration ); + 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_DOPivotY(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + + + + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOPivotY( _endValue, _duration ); + 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_DOSizeDelta(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector2 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapping = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.DOSizeDelta( _endValue, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector2 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOSizeDelta( _endValue, _duration ); + 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 UnityEngine.RectTransform.DOSizeDelta!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOPunchAnchorPos(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 6&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Vector2 _punch;translator.Get(L, 2, out _punch); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _elasticity = (float)LuaAPI.lua_tonumber(L, 5); + bool _snapping = LuaAPI.lua_toboolean(L, 6); + + var gen_ret = gen_to_be_invoked.DOPunchAnchorPos( _punch, _duration, _vibrato, _elasticity, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Vector2 _punch;translator.Get(L, 2, out _punch); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _elasticity = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = gen_to_be_invoked.DOPunchAnchorPos( _punch, _duration, _vibrato, _elasticity ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector2 _punch;translator.Get(L, 2, out _punch); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.DOPunchAnchorPos( _punch, _duration, _vibrato ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector2 _punch;translator.Get(L, 2, out _punch); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOPunchAnchorPos( _punch, _duration ); + 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 UnityEngine.RectTransform.DOPunchAnchorPos!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOShakeAnchorPos(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 7&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 7)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + float _strength = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _randomness = (float)LuaAPI.lua_tonumber(L, 5); + bool _snapping = LuaAPI.lua_toboolean(L, 6); + bool _fadeOut = LuaAPI.lua_toboolean(L, 7); + + var gen_ret = gen_to_be_invoked.DOShakeAnchorPos( _duration, _strength, _vibrato, _randomness, _snapping, _fadeOut ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + float _strength = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _randomness = (float)LuaAPI.lua_tonumber(L, 5); + bool _snapping = LuaAPI.lua_toboolean(L, 6); + + var gen_ret = gen_to_be_invoked.DOShakeAnchorPos( _duration, _strength, _vibrato, _randomness, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + float _strength = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _randomness = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = gen_to_be_invoked.DOShakeAnchorPos( _duration, _strength, _vibrato, _randomness ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + float _strength = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.DOShakeAnchorPos( _duration, _strength, _vibrato ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + float _strength = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOShakeAnchorPos( _duration, _strength ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.DOShakeAnchorPos( _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 7&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 7)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector2 _strength;translator.Get(L, 3, out _strength); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _randomness = (float)LuaAPI.lua_tonumber(L, 5); + bool _snapping = LuaAPI.lua_toboolean(L, 6); + bool _fadeOut = LuaAPI.lua_toboolean(L, 7); + + var gen_ret = gen_to_be_invoked.DOShakeAnchorPos( _duration, _strength, _vibrato, _randomness, _snapping, _fadeOut ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector2 _strength;translator.Get(L, 3, out _strength); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _randomness = (float)LuaAPI.lua_tonumber(L, 5); + bool _snapping = LuaAPI.lua_toboolean(L, 6); + + var gen_ret = gen_to_be_invoked.DOShakeAnchorPos( _duration, _strength, _vibrato, _randomness, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector2 _strength;translator.Get(L, 3, out _strength); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _randomness = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = gen_to_be_invoked.DOShakeAnchorPos( _duration, _strength, _vibrato, _randomness ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector2 _strength;translator.Get(L, 3, out _strength); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.DOShakeAnchorPos( _duration, _strength, _vibrato ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector2 _strength;translator.Get(L, 3, out _strength); + + var gen_ret = gen_to_be_invoked.DOShakeAnchorPos( _duration, _strength ); + 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 UnityEngine.RectTransform.DOShakeAnchorPos!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOJumpAnchorPos(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 6&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Vector2 _endValue;translator.Get(L, 2, out _endValue); + float _jumpPower = (float)LuaAPI.lua_tonumber(L, 3); + int _numJumps = LuaAPI.xlua_tointeger(L, 4); + float _duration = (float)LuaAPI.lua_tonumber(L, 5); + bool _snapping = LuaAPI.lua_toboolean(L, 6); + + var gen_ret = gen_to_be_invoked.DOJumpAnchorPos( _endValue, _jumpPower, _numJumps, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Vector2 _endValue;translator.Get(L, 2, out _endValue); + float _jumpPower = (float)LuaAPI.lua_tonumber(L, 3); + int _numJumps = LuaAPI.xlua_tointeger(L, 4); + float _duration = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = gen_to_be_invoked.DOJumpAnchorPos( _endValue, _jumpPower, _numJumps, _duration ); + 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 UnityEngine.RectTransform.DOJumpAnchorPos!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.rect); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_anchorMin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.anchorMin); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_anchorMax(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.anchorMax); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_anchoredPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.anchoredPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sizeDelta(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.sizeDelta); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_pivot(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.pivot); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_anchoredPosition3D(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.anchoredPosition3D); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_offsetMin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.offsetMin); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_offsetMax(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.offsetMax); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_drivenByObject(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.drivenByObject); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_anchorMin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.anchorMin = 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_anchorMax(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.anchorMax = 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_anchoredPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.anchoredPosition = 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_sizeDelta(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.sizeDelta = 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_pivot(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.pivot = 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_anchoredPosition3D(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.anchoredPosition3D = 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_offsetMin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.offsetMin = 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_offsetMax(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RectTransform gen_to_be_invoked = (UnityEngine.RectTransform)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.offsetMax = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_reapplyDrivenProperties(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + UnityEngine.RectTransform.ReapplyDrivenProperties gen_delegate = translator.GetDelegate(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need UnityEngine.RectTransform.ReapplyDrivenProperties!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + UnityEngine.RectTransform.reapplyDrivenProperties += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + UnityEngine.RectTransform.reapplyDrivenProperties -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.RectTransform.reapplyDrivenProperties!"); + } + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_RectWrap.cs b/Assets/XLua/Gen/UnityEngine_RectWrap.cs new file mode 100644 index 000000000..b0735e182 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_RectWrap.cs @@ -0,0 +1,965 @@ +#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 UnityEngineRectWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Rect); + Utils.BeginObjectRegister(type, L, translator, 1, 6, 13, 13); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__eq", __EqMeta); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Set", _m_Set); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Contains", _m_Contains); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Overlaps", _m_Overlaps); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashCode", _m_GetHashCode); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Equals", _m_Equals); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "x", _g_get_x); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "y", _g_get_y); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "position", _g_get_position); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "center", _g_get_center); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "min", _g_get_min); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "max", _g_get_max); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "width", _g_get_width); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "height", _g_get_height); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "size", _g_get_size); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "xMin", _g_get_xMin); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "yMin", _g_get_yMin); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "xMax", _g_get_xMax); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "yMax", _g_get_yMax); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "x", _s_set_x); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "y", _s_set_y); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "position", _s_set_position); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "center", _s_set_center); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "min", _s_set_min); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "max", _s_set_max); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "width", _s_set_width); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "height", _s_set_height); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "size", _s_set_size); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "xMin", _s_set_xMin); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "yMin", _s_set_yMin); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "xMax", _s_set_xMax); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "yMax", _s_set_yMax); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 4, 1, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "MinMaxRect", _m_MinMaxRect_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "NormalizedToPoint", _m_NormalizedToPoint_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "PointToNormalized", _m_PointToNormalized_xlua_st_); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "zero", _g_get_zero); + + + + 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) == 5 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _width = (float)LuaAPI.lua_tonumber(L, 4); + float _height = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = new UnityEngine.Rect(_x, _y, _width, _height); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 3 && translator.Assignable(L, 2) && translator.Assignable(L, 3)) + { + UnityEngine.Vector2 _position;translator.Get(L, 2, out _position); + UnityEngine.Vector2 _size;translator.Get(L, 3, out _size); + + var gen_ret = new UnityEngine.Rect(_position, _size); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && translator.Assignable(L, 2)) + { + UnityEngine.Rect _source;translator.Get(L, 2, out _source); + + var gen_ret = new UnityEngine.Rect(_source); + translator.Push(L, gen_ret); + + return 1; + } + + if (LuaAPI.lua_gettop(L) == 1) + { + translator.Push(L, default(UnityEngine.Rect)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Rect constructor!"); + + } + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __EqMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + UnityEngine.Rect leftside;translator.Get(L, 1, out leftside); + UnityEngine.Rect rightside;translator.Get(L, 2, out rightside); + + LuaAPI.lua_pushboolean(L, leftside == rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of == operator, need UnityEngine.Rect!"); + + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_MinMaxRect_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + float _xmin = (float)LuaAPI.lua_tonumber(L, 1); + float _ymin = (float)LuaAPI.lua_tonumber(L, 2); + float _xmax = (float)LuaAPI.lua_tonumber(L, 3); + float _ymax = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = UnityEngine.Rect.MinMaxRect( _xmin, _ymin, _xmax, _ymax ); + 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_Set(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _width = (float)LuaAPI.lua_tonumber(L, 4); + float _height = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.Set( _x, _y, _width, _height ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Contains(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector2 _point;translator.Get(L, 2, out _point); + + var gen_ret = gen_to_be_invoked.Contains( _point ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _point;translator.Get(L, 2, out _point); + + var gen_ret = gen_to_be_invoked.Contains( _point ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _point;translator.Get(L, 2, out _point); + bool _allowInverse = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.Contains( _point, _allowInverse ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Rect.Contains!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Overlaps(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Rect _other;translator.Get(L, 2, out _other); + + var gen_ret = gen_to_be_invoked.Overlaps( _other ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Rect _other;translator.Get(L, 2, out _other); + bool _allowInverse = LuaAPI.lua_toboolean(L, 3); + + var gen_ret = gen_to_be_invoked.Overlaps( _other, _allowInverse ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Rect.Overlaps!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_NormalizedToPoint_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Rect _rectangle;translator.Get(L, 1, out _rectangle); + UnityEngine.Vector2 _normalizedRectCoordinates;translator.Get(L, 2, out _normalizedRectCoordinates); + + var gen_ret = UnityEngine.Rect.NormalizedToPoint( _rectangle, _normalizedRectCoordinates ); + translator.PushUnityEngineVector2(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_PointToNormalized_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Rect _rectangle;translator.Get(L, 1, out _rectangle); + UnityEngine.Vector2 _point;translator.Get(L, 2, out _point); + + var gen_ret = UnityEngine.Rect.PointToNormalized( _rectangle, _point ); + translator.PushUnityEngineVector2(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_GetHashCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.GetHashCode( ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Equals(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _other = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.Equals( _other ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Rect _other;translator.Get(L, 2, out _other); + + var gen_ret = gen_to_be_invoked.Equals( _other ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Rect.Equals!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.ToString( ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _format = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.ToString( _format ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _format = LuaAPI.lua_tostring(L, 2); + System.IFormatProvider _formatProvider = (System.IFormatProvider)translator.GetObject(L, 3, typeof(System.IFormatProvider)); + + var gen_ret = gen_to_be_invoked.ToString( _format, _formatProvider ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Rect.ToString!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_zero(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Rect.zero); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_x(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.x); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_y(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.y); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_position(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.position); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_center(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.center); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_min(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.min); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_max(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.max); + } 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); + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(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); + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(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 _g_get_size(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.size); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_xMin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.xMin); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_yMin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.yMin); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_xMax(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.xMax); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_yMax(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.yMax); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_x(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.x = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_y(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.y = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_position(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.position = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_center(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.center = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_min(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.min = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_max(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.max = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } 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); + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.width = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } 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); + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.height = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_size(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.size = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_xMin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.xMin = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_yMin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.yMin = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_xMax(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.xMax = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_yMax(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rect gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.yMax = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ReflectionProbeWrap.cs b/Assets/XLua/Gen/UnityEngine_ReflectionProbeWrap.cs new file mode 100644 index 000000000..da3823d00 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ReflectionProbeWrap.cs @@ -0,0 +1,1056 @@ +#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 UnityEngineReflectionProbeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ReflectionProbe); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 24, 21); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Reset", _m_Reset); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RenderProbe", _m_RenderProbe); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsFinishedRendering", _m_IsFinishedRendering); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "size", _g_get_size); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "center", _g_get_center); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "nearClipPlane", _g_get_nearClipPlane); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "farClipPlane", _g_get_farClipPlane); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "intensity", _g_get_intensity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bounds", _g_get_bounds); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "hdr", _g_get_hdr); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "renderDynamicObjects", _g_get_renderDynamicObjects); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "shadowDistance", _g_get_shadowDistance); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "resolution", _g_get_resolution); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "cullingMask", _g_get_cullingMask); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "clearFlags", _g_get_clearFlags); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "backgroundColor", _g_get_backgroundColor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "blendDistance", _g_get_blendDistance); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "boxProjection", _g_get_boxProjection); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mode", _g_get_mode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "importance", _g_get_importance); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "refreshMode", _g_get_refreshMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "timeSlicingMode", _g_get_timeSlicingMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bakedTexture", _g_get_bakedTexture); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "customBakedTexture", _g_get_customBakedTexture); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "realtimeTexture", _g_get_realtimeTexture); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "texture", _g_get_texture); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "textureHDRDecodeValues", _g_get_textureHDRDecodeValues); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "size", _s_set_size); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "center", _s_set_center); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "nearClipPlane", _s_set_nearClipPlane); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "farClipPlane", _s_set_farClipPlane); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "intensity", _s_set_intensity); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "hdr", _s_set_hdr); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "renderDynamicObjects", _s_set_renderDynamicObjects); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "shadowDistance", _s_set_shadowDistance); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "resolution", _s_set_resolution); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "cullingMask", _s_set_cullingMask); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "clearFlags", _s_set_clearFlags); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "backgroundColor", _s_set_backgroundColor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "blendDistance", _s_set_blendDistance); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "boxProjection", _s_set_boxProjection); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "mode", _s_set_mode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "importance", _s_set_importance); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "refreshMode", _s_set_refreshMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "timeSlicingMode", _s_set_timeSlicingMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "bakedTexture", _s_set_bakedTexture); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "customBakedTexture", _s_set_customBakedTexture); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "realtimeTexture", _s_set_realtimeTexture); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 5, 4, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "BlendCubemap", _m_BlendCubemap_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "UpdateCachedState", _m_UpdateCachedState_xlua_st_); + + Utils.RegisterFunc(L, Utils.CLS_IDX, "reflectionProbeChanged", _e_reflectionProbeChanged); + Utils.RegisterFunc(L, Utils.CLS_IDX, "defaultReflectionTexture", _e_defaultReflectionTexture); + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "minBakedCubemapResolution", _g_get_minBakedCubemapResolution); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "maxBakedCubemapResolution", _g_get_maxBakedCubemapResolution); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "defaultTextureHDRDecodeValues", _g_get_defaultTextureHDRDecodeValues); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "defaultTexture", _g_get_defaultTexture); + + + + 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 UnityEngine.ReflectionProbe(); + 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 UnityEngine.ReflectionProbe constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Reset(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Reset( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RenderProbe(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.RenderProbe( ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.RenderTexture _targetTexture = (UnityEngine.RenderTexture)translator.GetObject(L, 2, typeof(UnityEngine.RenderTexture)); + + var gen_ret = gen_to_be_invoked.RenderProbe( _targetTexture ); + LuaAPI.xlua_pushinteger(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 UnityEngine.ReflectionProbe.RenderProbe!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsFinishedRendering(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + + + + { + int _renderId = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.IsFinishedRendering( _renderId ); + 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_BlendCubemap_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Texture _src = (UnityEngine.Texture)translator.GetObject(L, 1, typeof(UnityEngine.Texture)); + UnityEngine.Texture _dst = (UnityEngine.Texture)translator.GetObject(L, 2, typeof(UnityEngine.Texture)); + float _blend = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.RenderTexture _target = (UnityEngine.RenderTexture)translator.GetObject(L, 4, typeof(UnityEngine.RenderTexture)); + + var gen_ret = UnityEngine.ReflectionProbe.BlendCubemap( _src, _dst, _blend, _target ); + 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_UpdateCachedState_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + UnityEngine.ReflectionProbe.UpdateCachedState( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_size(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.size); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_center(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.center); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_nearClipPlane(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.nearClipPlane); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_farClipPlane(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.farClipPlane); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_intensity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.intensity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bounds(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineBounds(L, gen_to_be_invoked.bounds); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_hdr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hdr); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_renderDynamicObjects(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.renderDynamicObjects); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_shadowDistance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.shadowDistance); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_resolution(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.resolution); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cullingMask(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.cullingMask); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_clearFlags(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.clearFlags); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_backgroundColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineColor(L, gen_to_be_invoked.backgroundColor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_blendDistance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.blendDistance); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_boxProjection(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.boxProjection); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.mode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_importance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.importance); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_refreshMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.refreshMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_timeSlicingMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.timeSlicingMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bakedTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.bakedTexture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_customBakedTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.customBakedTexture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_realtimeTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.realtimeTexture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_texture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.texture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_textureHDRDecodeValues(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector4(L, gen_to_be_invoked.textureHDRDecodeValues); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_minBakedCubemapResolution(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.ReflectionProbe.minBakedCubemapResolution); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxBakedCubemapResolution(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.ReflectionProbe.maxBakedCubemapResolution); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_defaultTextureHDRDecodeValues(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineVector4(L, UnityEngine.ReflectionProbe.defaultTextureHDRDecodeValues); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_defaultTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.ReflectionProbe.defaultTexture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_size(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.size = 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_center(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.center = 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_nearClipPlane(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.nearClipPlane = (float)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_farClipPlane(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.farClipPlane = (float)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_intensity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.intensity = (float)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_hdr(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.hdr = 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_renderDynamicObjects(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.renderDynamicObjects = 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_shadowDistance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.shadowDistance = (float)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_resolution(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.resolution = 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_cullingMask(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.cullingMask = 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_clearFlags(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + UnityEngine.Rendering.ReflectionProbeClearFlags gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.clearFlags = 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_backgroundColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + UnityEngine.Color gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.backgroundColor = 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_blendDistance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.blendDistance = (float)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_boxProjection(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.boxProjection = 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_mode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + UnityEngine.Rendering.ReflectionProbeMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.mode = 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_importance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.importance = 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_refreshMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + UnityEngine.Rendering.ReflectionProbeRefreshMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.refreshMode = 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_timeSlicingMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + UnityEngine.Rendering.ReflectionProbeTimeSlicingMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.timeSlicingMode = 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_bakedTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.bakedTexture = (UnityEngine.Texture)translator.GetObject(L, 2, typeof(UnityEngine.Texture)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_customBakedTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.customBakedTexture = (UnityEngine.Texture)translator.GetObject(L, 2, typeof(UnityEngine.Texture)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_realtimeTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ReflectionProbe gen_to_be_invoked = (UnityEngine.ReflectionProbe)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.realtimeTexture = (UnityEngine.RenderTexture)translator.GetObject(L, 2, typeof(UnityEngine.RenderTexture)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_reflectionProbeChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + UnityEngine.ReflectionProbe.reflectionProbeChanged += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + UnityEngine.ReflectionProbe.reflectionProbeChanged -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ReflectionProbe.reflectionProbeChanged!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_defaultReflectionTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + System.Action gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need System.Action!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + UnityEngine.ReflectionProbe.defaultReflectionTexture += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + UnityEngine.ReflectionProbe.defaultReflectionTexture -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ReflectionProbe.defaultReflectionTexture!"); + } + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_RenderSettingsWrap.cs b/Assets/XLua/Gen/UnityEngine_RenderSettingsWrap.cs new file mode 100644 index 000000000..3e77b8367 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_RenderSettingsWrap.cs @@ -0,0 +1,725 @@ +#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 UnityEngineRenderSettingsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.RenderSettings); + 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, 24, 24); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "fog", _g_get_fog); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "fogStartDistance", _g_get_fogStartDistance); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "fogEndDistance", _g_get_fogEndDistance); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "fogMode", _g_get_fogMode); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "fogColor", _g_get_fogColor); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "fogDensity", _g_get_fogDensity); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "ambientMode", _g_get_ambientMode); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "ambientSkyColor", _g_get_ambientSkyColor); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "ambientEquatorColor", _g_get_ambientEquatorColor); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "ambientGroundColor", _g_get_ambientGroundColor); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "ambientIntensity", _g_get_ambientIntensity); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "ambientLight", _g_get_ambientLight); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "subtractiveShadowColor", _g_get_subtractiveShadowColor); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "skybox", _g_get_skybox); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "sun", _g_get_sun); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "ambientProbe", _g_get_ambientProbe); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "customReflection", _g_get_customReflection); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "reflectionIntensity", _g_get_reflectionIntensity); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "reflectionBounces", _g_get_reflectionBounces); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "defaultReflectionMode", _g_get_defaultReflectionMode); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "defaultReflectionResolution", _g_get_defaultReflectionResolution); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "haloStrength", _g_get_haloStrength); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "flareStrength", _g_get_flareStrength); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "flareFadeSpeed", _g_get_flareFadeSpeed); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "fog", _s_set_fog); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "fogStartDistance", _s_set_fogStartDistance); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "fogEndDistance", _s_set_fogEndDistance); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "fogMode", _s_set_fogMode); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "fogColor", _s_set_fogColor); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "fogDensity", _s_set_fogDensity); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "ambientMode", _s_set_ambientMode); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "ambientSkyColor", _s_set_ambientSkyColor); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "ambientEquatorColor", _s_set_ambientEquatorColor); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "ambientGroundColor", _s_set_ambientGroundColor); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "ambientIntensity", _s_set_ambientIntensity); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "ambientLight", _s_set_ambientLight); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "subtractiveShadowColor", _s_set_subtractiveShadowColor); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "skybox", _s_set_skybox); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "sun", _s_set_sun); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "ambientProbe", _s_set_ambientProbe); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "customReflection", _s_set_customReflection); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "reflectionIntensity", _s_set_reflectionIntensity); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "reflectionBounces", _s_set_reflectionBounces); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "defaultReflectionMode", _s_set_defaultReflectionMode); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "defaultReflectionResolution", _s_set_defaultReflectionResolution); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "haloStrength", _s_set_haloStrength); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "flareStrength", _s_set_flareStrength); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "flareFadeSpeed", _s_set_flareFadeSpeed); + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "UnityEngine.RenderSettings does not have a constructor!"); + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fog(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.RenderSettings.fog); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fogStartDistance(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.RenderSettings.fogStartDistance); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fogEndDistance(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.RenderSettings.fogEndDistance); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fogMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.RenderSettings.fogMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fogColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineColor(L, UnityEngine.RenderSettings.fogColor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fogDensity(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.RenderSettings.fogDensity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ambientMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.RenderSettings.ambientMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ambientSkyColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineColor(L, UnityEngine.RenderSettings.ambientSkyColor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ambientEquatorColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineColor(L, UnityEngine.RenderSettings.ambientEquatorColor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ambientGroundColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineColor(L, UnityEngine.RenderSettings.ambientGroundColor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ambientIntensity(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.RenderSettings.ambientIntensity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ambientLight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineColor(L, UnityEngine.RenderSettings.ambientLight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_subtractiveShadowColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineColor(L, UnityEngine.RenderSettings.subtractiveShadowColor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_skybox(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.RenderSettings.skybox); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sun(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.RenderSettings.sun); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ambientProbe(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.RenderSettings.ambientProbe); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_customReflection(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.RenderSettings.customReflection); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_reflectionIntensity(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.RenderSettings.reflectionIntensity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_reflectionBounces(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.RenderSettings.reflectionBounces); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_defaultReflectionMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.RenderSettings.defaultReflectionMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_defaultReflectionResolution(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.RenderSettings.defaultReflectionResolution); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_haloStrength(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.RenderSettings.haloStrength); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_flareStrength(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.RenderSettings.flareStrength); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_flareFadeSpeed(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.RenderSettings.flareFadeSpeed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_fog(RealStatePtr L) + { + try { + + UnityEngine.RenderSettings.fog = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_fogStartDistance(RealStatePtr L) + { + try { + + UnityEngine.RenderSettings.fogStartDistance = (float)LuaAPI.lua_tonumber(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_fogEndDistance(RealStatePtr L) + { + try { + + UnityEngine.RenderSettings.fogEndDistance = (float)LuaAPI.lua_tonumber(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_fogMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + UnityEngine.FogMode gen_value;translator.Get(L, 1, out gen_value); + UnityEngine.RenderSettings.fogMode = 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_fogColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + UnityEngine.Color gen_value;translator.Get(L, 1, out gen_value); + UnityEngine.RenderSettings.fogColor = 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_fogDensity(RealStatePtr L) + { + try { + + UnityEngine.RenderSettings.fogDensity = (float)LuaAPI.lua_tonumber(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_ambientMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + UnityEngine.Rendering.AmbientMode gen_value;translator.Get(L, 1, out gen_value); + UnityEngine.RenderSettings.ambientMode = 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_ambientSkyColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + UnityEngine.Color gen_value;translator.Get(L, 1, out gen_value); + UnityEngine.RenderSettings.ambientSkyColor = 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_ambientEquatorColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + UnityEngine.Color gen_value;translator.Get(L, 1, out gen_value); + UnityEngine.RenderSettings.ambientEquatorColor = 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_ambientGroundColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + UnityEngine.Color gen_value;translator.Get(L, 1, out gen_value); + UnityEngine.RenderSettings.ambientGroundColor = 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_ambientIntensity(RealStatePtr L) + { + try { + + UnityEngine.RenderSettings.ambientIntensity = (float)LuaAPI.lua_tonumber(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_ambientLight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + UnityEngine.Color gen_value;translator.Get(L, 1, out gen_value); + UnityEngine.RenderSettings.ambientLight = 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_subtractiveShadowColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + UnityEngine.Color gen_value;translator.Get(L, 1, out gen_value); + UnityEngine.RenderSettings.subtractiveShadowColor = 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_skybox(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + UnityEngine.RenderSettings.skybox = (UnityEngine.Material)translator.GetObject(L, 1, typeof(UnityEngine.Material)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_sun(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + UnityEngine.RenderSettings.sun = (UnityEngine.Light)translator.GetObject(L, 1, typeof(UnityEngine.Light)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_ambientProbe(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + UnityEngine.Rendering.SphericalHarmonicsL2 gen_value;translator.Get(L, 1, out gen_value); + UnityEngine.RenderSettings.ambientProbe = 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_customReflection(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + UnityEngine.RenderSettings.customReflection = (UnityEngine.Texture)translator.GetObject(L, 1, typeof(UnityEngine.Texture)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_reflectionIntensity(RealStatePtr L) + { + try { + + UnityEngine.RenderSettings.reflectionIntensity = (float)LuaAPI.lua_tonumber(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_reflectionBounces(RealStatePtr L) + { + try { + + UnityEngine.RenderSettings.reflectionBounces = LuaAPI.xlua_tointeger(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_defaultReflectionMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + UnityEngine.Rendering.DefaultReflectionMode gen_value;translator.Get(L, 1, out gen_value); + UnityEngine.RenderSettings.defaultReflectionMode = 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_defaultReflectionResolution(RealStatePtr L) + { + try { + + UnityEngine.RenderSettings.defaultReflectionResolution = LuaAPI.xlua_tointeger(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_haloStrength(RealStatePtr L) + { + try { + + UnityEngine.RenderSettings.haloStrength = (float)LuaAPI.lua_tonumber(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_flareStrength(RealStatePtr L) + { + try { + + UnityEngine.RenderSettings.flareStrength = (float)LuaAPI.lua_tonumber(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_flareFadeSpeed(RealStatePtr L) + { + try { + + UnityEngine.RenderSettings.flareFadeSpeed = (float)LuaAPI.lua_tonumber(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_RenderTextureDescriptorWrap.cs b/Assets/XLua/Gen/UnityEngine_RenderTextureDescriptorWrap.cs new file mode 100644 index 000000000..07fa6c2ea --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_RenderTextureDescriptorWrap.cs @@ -0,0 +1,875 @@ +#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 UnityEngineRenderTextureDescriptorWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.RenderTextureDescriptor); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 21, 20); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "width", _g_get_width); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "height", _g_get_height); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "msaaSamples", _g_get_msaaSamples); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "volumeDepth", _g_get_volumeDepth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mipCount", _g_get_mipCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "graphicsFormat", _g_get_graphicsFormat); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "stencilFormat", _g_get_stencilFormat); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "depthStencilFormat", _g_get_depthStencilFormat); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "colorFormat", _g_get_colorFormat); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sRGB", _g_get_sRGB); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "depthBufferBits", _g_get_depthBufferBits); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "dimension", _g_get_dimension); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "shadowSamplingMode", _g_get_shadowSamplingMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "vrUsage", _g_get_vrUsage); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "flags", _g_get_flags); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "memoryless", _g_get_memoryless); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "useMipMap", _g_get_useMipMap); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "autoGenerateMips", _g_get_autoGenerateMips); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enableRandomWrite", _g_get_enableRandomWrite); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bindMS", _g_get_bindMS); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "useDynamicScale", _g_get_useDynamicScale); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "width", _s_set_width); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "height", _s_set_height); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "msaaSamples", _s_set_msaaSamples); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "volumeDepth", _s_set_volumeDepth); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "mipCount", _s_set_mipCount); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "graphicsFormat", _s_set_graphicsFormat); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "stencilFormat", _s_set_stencilFormat); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "depthStencilFormat", _s_set_depthStencilFormat); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "colorFormat", _s_set_colorFormat); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sRGB", _s_set_sRGB); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "depthBufferBits", _s_set_depthBufferBits); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "dimension", _s_set_dimension); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "shadowSamplingMode", _s_set_shadowSamplingMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "vrUsage", _s_set_vrUsage); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "memoryless", _s_set_memoryless); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "useMipMap", _s_set_useMipMap); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "autoGenerateMips", _s_set_autoGenerateMips); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enableRandomWrite", _s_set_enableRandomWrite); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "bindMS", _s_set_bindMS); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "useDynamicScale", _s_set_useDynamicScale); + + + 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 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _width = LuaAPI.xlua_tointeger(L, 2); + int _height = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = new UnityEngine.RenderTextureDescriptor(_width, _height); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 4 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && translator.Assignable(L, 4)) + { + int _width = LuaAPI.xlua_tointeger(L, 2); + int _height = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.RenderTextureFormat _colorFormat;translator.Get(L, 4, out _colorFormat); + + var gen_ret = new UnityEngine.RenderTextureDescriptor(_width, _height, _colorFormat); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 5 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && translator.Assignable(L, 4) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int _width = LuaAPI.xlua_tointeger(L, 2); + int _height = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.RenderTextureFormat _colorFormat;translator.Get(L, 4, out _colorFormat); + int _depthBufferBits = LuaAPI.xlua_tointeger(L, 5); + + var gen_ret = new UnityEngine.RenderTextureDescriptor(_width, _height, _colorFormat, _depthBufferBits); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 5 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && translator.Assignable(L, 4) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int _width = LuaAPI.xlua_tointeger(L, 2); + int _height = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.Experimental.Rendering.GraphicsFormat _colorFormat;translator.Get(L, 4, out _colorFormat); + int _depthBufferBits = LuaAPI.xlua_tointeger(L, 5); + + var gen_ret = new UnityEngine.RenderTextureDescriptor(_width, _height, _colorFormat, _depthBufferBits); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 6 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && translator.Assignable(L, 4) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + int _width = LuaAPI.xlua_tointeger(L, 2); + int _height = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.RenderTextureFormat _colorFormat;translator.Get(L, 4, out _colorFormat); + int _depthBufferBits = LuaAPI.xlua_tointeger(L, 5); + int _mipCount = LuaAPI.xlua_tointeger(L, 6); + + var gen_ret = new UnityEngine.RenderTextureDescriptor(_width, _height, _colorFormat, _depthBufferBits, _mipCount); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 7 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && translator.Assignable(L, 4) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6) && translator.Assignable(L, 7)) + { + int _width = LuaAPI.xlua_tointeger(L, 2); + int _height = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.RenderTextureFormat _colorFormat;translator.Get(L, 4, out _colorFormat); + int _depthBufferBits = LuaAPI.xlua_tointeger(L, 5); + int _mipCount = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.RenderTextureReadWrite _readWrite;translator.Get(L, 7, out _readWrite); + + var gen_ret = new UnityEngine.RenderTextureDescriptor(_width, _height, _colorFormat, _depthBufferBits, _mipCount, _readWrite); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 6 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && translator.Assignable(L, 4) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + int _width = LuaAPI.xlua_tointeger(L, 2); + int _height = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.Experimental.Rendering.GraphicsFormat _colorFormat;translator.Get(L, 4, out _colorFormat); + int _depthBufferBits = LuaAPI.xlua_tointeger(L, 5); + int _mipCount = LuaAPI.xlua_tointeger(L, 6); + + var gen_ret = new UnityEngine.RenderTextureDescriptor(_width, _height, _colorFormat, _depthBufferBits, _mipCount); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 5 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && translator.Assignable(L, 4) && translator.Assignable(L, 5)) + { + int _width = LuaAPI.xlua_tointeger(L, 2); + int _height = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.Experimental.Rendering.GraphicsFormat _colorFormat;translator.Get(L, 4, out _colorFormat); + UnityEngine.Experimental.Rendering.GraphicsFormat _depthStencilFormat;translator.Get(L, 5, out _depthStencilFormat); + + var gen_ret = new UnityEngine.RenderTextureDescriptor(_width, _height, _colorFormat, _depthStencilFormat); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 6 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && translator.Assignable(L, 4) && translator.Assignable(L, 5) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + int _width = LuaAPI.xlua_tointeger(L, 2); + int _height = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.Experimental.Rendering.GraphicsFormat _colorFormat;translator.Get(L, 4, out _colorFormat); + UnityEngine.Experimental.Rendering.GraphicsFormat _depthStencilFormat;translator.Get(L, 5, out _depthStencilFormat); + int _mipCount = LuaAPI.xlua_tointeger(L, 6); + + var gen_ret = new UnityEngine.RenderTextureDescriptor(_width, _height, _colorFormat, _depthStencilFormat, _mipCount); + translator.Push(L, gen_ret); + + return 1; + } + + if (LuaAPI.lua_gettop(L) == 1) + { + translator.Push(L, default(UnityEngine.RenderTextureDescriptor)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.RenderTextureDescriptor constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_width(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + 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); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + 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 _g_get_msaaSamples(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.msaaSamples); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_volumeDepth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.volumeDepth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mipCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.mipCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_graphicsFormat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.graphicsFormat); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_stencilFormat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.stencilFormat); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_depthStencilFormat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.depthStencilFormat); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_colorFormat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineRenderTextureFormat(L, gen_to_be_invoked.colorFormat); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sRGB(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.sRGB); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_depthBufferBits(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.depthBufferBits); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_dimension(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.dimension); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_shadowSamplingMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.shadowSamplingMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_vrUsage(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.vrUsage); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_flags(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.flags); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_memoryless(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.memoryless); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_useMipMap(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.useMipMap); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_autoGenerateMips(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.autoGenerateMips); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enableRandomWrite(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.enableRandomWrite); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bindMS(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.bindMS); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_useDynamicScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.useDynamicScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_width(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.width = LuaAPI.xlua_tointeger(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } 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); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.height = LuaAPI.xlua_tointeger(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_msaaSamples(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.msaaSamples = LuaAPI.xlua_tointeger(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_volumeDepth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.volumeDepth = LuaAPI.xlua_tointeger(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_mipCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.mipCount = LuaAPI.xlua_tointeger(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_graphicsFormat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Experimental.Rendering.GraphicsFormat gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.graphicsFormat = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_stencilFormat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Experimental.Rendering.GraphicsFormat gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.stencilFormat = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_depthStencilFormat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Experimental.Rendering.GraphicsFormat gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.depthStencilFormat = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_colorFormat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.RenderTextureFormat gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.colorFormat = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_sRGB(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.sRGB = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_depthBufferBits(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.depthBufferBits = LuaAPI.xlua_tointeger(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_dimension(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Rendering.TextureDimension gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.dimension = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_shadowSamplingMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Rendering.ShadowSamplingMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.shadowSamplingMode = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_vrUsage(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.VRTextureUsage gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.vrUsage = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_memoryless(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.RenderTextureMemoryless gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.memoryless = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_useMipMap(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.useMipMap = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_autoGenerateMips(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.autoGenerateMips = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_enableRandomWrite(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.enableRandomWrite = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_bindMS(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.bindMS = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_useDynamicScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTextureDescriptor gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.useDynamicScale = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_RenderTextureWrap.cs b/Assets/XLua/Gen/UnityEngine_RenderTextureWrap.cs new file mode 100644 index 000000000..1121ffafe --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_RenderTextureWrap.cs @@ -0,0 +1,1466 @@ +#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 UnityEngineRenderTextureWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.RenderTexture); + Utils.BeginObjectRegister(type, L, translator, 0, 9, 22, 19); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNativeDepthBufferPtr", _m_GetNativeDepthBufferPtr); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DiscardContents", _m_DiscardContents); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResolveAntiAliasedSurface", _m_ResolveAntiAliasedSurface); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetGlobalShaderProperty", _m_SetGlobalShaderProperty); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Create", _m_Create); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Release", _m_Release); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsCreated", _m_IsCreated); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GenerateMips", _m_GenerateMips); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ConvertToEquirect", _m_ConvertToEquirect); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "descriptor", _g_get_descriptor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "width", _g_get_width); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "height", _g_get_height); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "dimension", _g_get_dimension); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "graphicsFormat", _g_get_graphicsFormat); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "useMipMap", _g_get_useMipMap); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sRGB", _g_get_sRGB); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "vrUsage", _g_get_vrUsage); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "memorylessMode", _g_get_memorylessMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "format", _g_get_format); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "stencilFormat", _g_get_stencilFormat); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "depthStencilFormat", _g_get_depthStencilFormat); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "autoGenerateMips", _g_get_autoGenerateMips); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "volumeDepth", _g_get_volumeDepth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "antiAliasing", _g_get_antiAliasing); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bindTextureMS", _g_get_bindTextureMS); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enableRandomWrite", _g_get_enableRandomWrite); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "useDynamicScale", _g_get_useDynamicScale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isPowerOfTwo", _g_get_isPowerOfTwo); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "colorBuffer", _g_get_colorBuffer); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "depthBuffer", _g_get_depthBuffer); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "depth", _g_get_depth); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "descriptor", _s_set_descriptor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "width", _s_set_width); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "height", _s_set_height); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "dimension", _s_set_dimension); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "graphicsFormat", _s_set_graphicsFormat); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "useMipMap", _s_set_useMipMap); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "vrUsage", _s_set_vrUsage); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "memorylessMode", _s_set_memorylessMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "format", _s_set_format); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "stencilFormat", _s_set_stencilFormat); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "depthStencilFormat", _s_set_depthStencilFormat); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "autoGenerateMips", _s_set_autoGenerateMips); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "volumeDepth", _s_set_volumeDepth); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "antiAliasing", _s_set_antiAliasing); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "bindTextureMS", _s_set_bindTextureMS); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enableRandomWrite", _s_set_enableRandomWrite); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "useDynamicScale", _s_set_useDynamicScale); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "isPowerOfTwo", _s_set_isPowerOfTwo); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "depth", _s_set_depth); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 4, 1, 1); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetTemporary", _m_GetTemporary_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SupportsStencil", _m_SupportsStencil_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ReleaseTemporary", _m_ReleaseTemporary_xlua_st_); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "active", _g_get_active); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "active", _s_set_active); + + + 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) == 2 && translator.Assignable(L, 2)) + { + UnityEngine.RenderTextureDescriptor _desc;translator.Get(L, 2, out _desc); + + var gen_ret = new UnityEngine.RenderTexture(_desc); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && translator.Assignable(L, 2)) + { + UnityEngine.RenderTexture _textureToCopy = (UnityEngine.RenderTexture)translator.GetObject(L, 2, typeof(UnityEngine.RenderTexture)); + + var gen_ret = new UnityEngine.RenderTexture(_textureToCopy); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 5 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4) && translator.Assignable(L, 5)) + { + int _width = LuaAPI.xlua_tointeger(L, 2); + int _height = LuaAPI.xlua_tointeger(L, 3); + int _depth = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.Experimental.Rendering.DefaultFormat _format;translator.Get(L, 5, out _format); + + var gen_ret = new UnityEngine.RenderTexture(_width, _height, _depth, _format); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 5 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4) && translator.Assignable(L, 5)) + { + int _width = LuaAPI.xlua_tointeger(L, 2); + int _height = LuaAPI.xlua_tointeger(L, 3); + int _depth = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.Experimental.Rendering.GraphicsFormat _format;translator.Get(L, 5, out _format); + + var gen_ret = new UnityEngine.RenderTexture(_width, _height, _depth, _format); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 6 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4) && translator.Assignable(L, 5) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + int _width = LuaAPI.xlua_tointeger(L, 2); + int _height = LuaAPI.xlua_tointeger(L, 3); + int _depth = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.Experimental.Rendering.GraphicsFormat _format;translator.Get(L, 5, out _format); + int _mipCount = LuaAPI.xlua_tointeger(L, 6); + + var gen_ret = new UnityEngine.RenderTexture(_width, _height, _depth, _format, _mipCount); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 6 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && translator.Assignable(L, 4) && translator.Assignable(L, 5) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + int _width = LuaAPI.xlua_tointeger(L, 2); + int _height = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.Experimental.Rendering.GraphicsFormat _colorFormat;translator.Get(L, 4, out _colorFormat); + UnityEngine.Experimental.Rendering.GraphicsFormat _depthStencilFormat;translator.Get(L, 5, out _depthStencilFormat); + int _mipCount = LuaAPI.xlua_tointeger(L, 6); + + var gen_ret = new UnityEngine.RenderTexture(_width, _height, _colorFormat, _depthStencilFormat, _mipCount); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 5 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && translator.Assignable(L, 4) && translator.Assignable(L, 5)) + { + int _width = LuaAPI.xlua_tointeger(L, 2); + int _height = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.Experimental.Rendering.GraphicsFormat _colorFormat;translator.Get(L, 4, out _colorFormat); + UnityEngine.Experimental.Rendering.GraphicsFormat _depthStencilFormat;translator.Get(L, 5, out _depthStencilFormat); + + var gen_ret = new UnityEngine.RenderTexture(_width, _height, _colorFormat, _depthStencilFormat); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 6 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4) && translator.Assignable(L, 5) && translator.Assignable(L, 6)) + { + int _width = LuaAPI.xlua_tointeger(L, 2); + int _height = LuaAPI.xlua_tointeger(L, 3); + int _depth = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.RenderTextureFormat _format;translator.Get(L, 5, out _format); + UnityEngine.RenderTextureReadWrite _readWrite;translator.Get(L, 6, out _readWrite); + + var gen_ret = new UnityEngine.RenderTexture(_width, _height, _depth, _format, _readWrite); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 5 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4) && translator.Assignable(L, 5)) + { + int _width = LuaAPI.xlua_tointeger(L, 2); + int _height = LuaAPI.xlua_tointeger(L, 3); + int _depth = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.RenderTextureFormat _format;translator.Get(L, 5, out _format); + + var gen_ret = new UnityEngine.RenderTexture(_width, _height, _depth, _format); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 4 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + int _width = LuaAPI.xlua_tointeger(L, 2); + int _height = LuaAPI.xlua_tointeger(L, 3); + int _depth = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = new UnityEngine.RenderTexture(_width, _height, _depth); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 6 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4) && translator.Assignable(L, 5) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + int _width = LuaAPI.xlua_tointeger(L, 2); + int _height = LuaAPI.xlua_tointeger(L, 3); + int _depth = LuaAPI.xlua_tointeger(L, 4); + UnityEngine.RenderTextureFormat _format;translator.Get(L, 5, out _format); + int _mipCount = LuaAPI.xlua_tointeger(L, 6); + + var gen_ret = new UnityEngine.RenderTexture(_width, _height, _depth, _format, _mipCount); + 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 UnityEngine.RenderTexture constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetTemporary_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _width = LuaAPI.xlua_tointeger(L, 1); + int _height = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = UnityEngine.RenderTexture.GetTemporary( _width, _height ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _width = LuaAPI.xlua_tointeger(L, 1); + int _height = LuaAPI.xlua_tointeger(L, 2); + int _depthBuffer = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = UnityEngine.RenderTexture.GetTemporary( _width, _height, _depthBuffer ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + UnityEngine.RenderTextureDescriptor _desc;translator.Get(L, 1, out _desc); + + var gen_ret = UnityEngine.RenderTexture.GetTemporary( _desc ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + int _width = LuaAPI.xlua_tointeger(L, 1); + int _height = LuaAPI.xlua_tointeger(L, 2); + int _depthBuffer = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.Experimental.Rendering.GraphicsFormat _format;translator.Get(L, 4, out _format); + + var gen_ret = UnityEngine.RenderTexture.GetTemporary( _width, _height, _depthBuffer, _format ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + int _width = LuaAPI.xlua_tointeger(L, 1); + int _height = LuaAPI.xlua_tointeger(L, 2); + int _depthBuffer = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.RenderTextureFormat _format;translator.Get(L, 4, out _format); + + var gen_ret = UnityEngine.RenderTexture.GetTemporary( _width, _height, _depthBuffer, _format ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int _width = LuaAPI.xlua_tointeger(L, 1); + int _height = LuaAPI.xlua_tointeger(L, 2); + int _depthBuffer = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.Experimental.Rendering.GraphicsFormat _format;translator.Get(L, 4, out _format); + int _antiAliasing = LuaAPI.xlua_tointeger(L, 5); + + var gen_ret = UnityEngine.RenderTexture.GetTemporary( _width, _height, _depthBuffer, _format, _antiAliasing ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)) + { + int _width = LuaAPI.xlua_tointeger(L, 1); + int _height = LuaAPI.xlua_tointeger(L, 2); + int _depthBuffer = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.RenderTextureFormat _format;translator.Get(L, 4, out _format); + UnityEngine.RenderTextureReadWrite _readWrite;translator.Get(L, 5, out _readWrite); + + var gen_ret = UnityEngine.RenderTexture.GetTemporary( _width, _height, _depthBuffer, _format, _readWrite ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)) + { + int _width = LuaAPI.xlua_tointeger(L, 1); + int _height = LuaAPI.xlua_tointeger(L, 2); + int _depthBuffer = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.Experimental.Rendering.GraphicsFormat _format;translator.Get(L, 4, out _format); + int _antiAliasing = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.RenderTextureMemoryless _memorylessMode;translator.Get(L, 6, out _memorylessMode); + + var gen_ret = UnityEngine.RenderTexture.GetTemporary( _width, _height, _depthBuffer, _format, _antiAliasing, _memorylessMode ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + int _width = LuaAPI.xlua_tointeger(L, 1); + int _height = LuaAPI.xlua_tointeger(L, 2); + int _depthBuffer = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.RenderTextureFormat _format;translator.Get(L, 4, out _format); + UnityEngine.RenderTextureReadWrite _readWrite;translator.Get(L, 5, out _readWrite); + int _antiAliasing = LuaAPI.xlua_tointeger(L, 6); + + var gen_ret = UnityEngine.RenderTexture.GetTemporary( _width, _height, _depthBuffer, _format, _readWrite, _antiAliasing ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 7&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& translator.Assignable(L, 7)) + { + int _width = LuaAPI.xlua_tointeger(L, 1); + int _height = LuaAPI.xlua_tointeger(L, 2); + int _depthBuffer = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.Experimental.Rendering.GraphicsFormat _format;translator.Get(L, 4, out _format); + int _antiAliasing = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.RenderTextureMemoryless _memorylessMode;translator.Get(L, 6, out _memorylessMode); + UnityEngine.VRTextureUsage _vrUsage;translator.Get(L, 7, out _vrUsage); + + var gen_ret = UnityEngine.RenderTexture.GetTemporary( _width, _height, _depthBuffer, _format, _antiAliasing, _memorylessMode, _vrUsage ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 7&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)) + { + int _width = LuaAPI.xlua_tointeger(L, 1); + int _height = LuaAPI.xlua_tointeger(L, 2); + int _depthBuffer = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.RenderTextureFormat _format;translator.Get(L, 4, out _format); + UnityEngine.RenderTextureReadWrite _readWrite;translator.Get(L, 5, out _readWrite); + int _antiAliasing = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.RenderTextureMemoryless _memorylessMode;translator.Get(L, 7, out _memorylessMode); + + var gen_ret = UnityEngine.RenderTexture.GetTemporary( _width, _height, _depthBuffer, _format, _readWrite, _antiAliasing, _memorylessMode ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 8&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& translator.Assignable(L, 7)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 8)) + { + int _width = LuaAPI.xlua_tointeger(L, 1); + int _height = LuaAPI.xlua_tointeger(L, 2); + int _depthBuffer = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.Experimental.Rendering.GraphicsFormat _format;translator.Get(L, 4, out _format); + int _antiAliasing = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.RenderTextureMemoryless _memorylessMode;translator.Get(L, 6, out _memorylessMode); + UnityEngine.VRTextureUsage _vrUsage;translator.Get(L, 7, out _vrUsage); + bool _useDynamicScale = LuaAPI.lua_toboolean(L, 8); + + var gen_ret = UnityEngine.RenderTexture.GetTemporary( _width, _height, _depthBuffer, _format, _antiAliasing, _memorylessMode, _vrUsage, _useDynamicScale ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 8&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)) + { + int _width = LuaAPI.xlua_tointeger(L, 1); + int _height = LuaAPI.xlua_tointeger(L, 2); + int _depthBuffer = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.RenderTextureFormat _format;translator.Get(L, 4, out _format); + UnityEngine.RenderTextureReadWrite _readWrite;translator.Get(L, 5, out _readWrite); + int _antiAliasing = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.RenderTextureMemoryless _memorylessMode;translator.Get(L, 7, out _memorylessMode); + UnityEngine.VRTextureUsage _vrUsage;translator.Get(L, 8, out _vrUsage); + + var gen_ret = UnityEngine.RenderTexture.GetTemporary( _width, _height, _depthBuffer, _format, _readWrite, _antiAliasing, _memorylessMode, _vrUsage ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 9&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable(L, 7)&& translator.Assignable(L, 8)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 9)) + { + int _width = LuaAPI.xlua_tointeger(L, 1); + int _height = LuaAPI.xlua_tointeger(L, 2); + int _depthBuffer = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.RenderTextureFormat _format;translator.Get(L, 4, out _format); + UnityEngine.RenderTextureReadWrite _readWrite;translator.Get(L, 5, out _readWrite); + int _antiAliasing = LuaAPI.xlua_tointeger(L, 6); + UnityEngine.RenderTextureMemoryless _memorylessMode;translator.Get(L, 7, out _memorylessMode); + UnityEngine.VRTextureUsage _vrUsage;translator.Get(L, 8, out _vrUsage); + bool _useDynamicScale = LuaAPI.lua_toboolean(L, 9); + + var gen_ret = UnityEngine.RenderTexture.GetTemporary( _width, _height, _depthBuffer, _format, _readWrite, _antiAliasing, _memorylessMode, _vrUsage, _useDynamicScale ); + 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 UnityEngine.RenderTexture.GetTemporary!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetNativeDepthBufferPtr(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetNativeDepthBufferPtr( ); + LuaAPI.lua_pushlightuserdata(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_DiscardContents(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.DiscardContents( ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + bool _discardColor = LuaAPI.lua_toboolean(L, 2); + bool _discardDepth = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.DiscardContents( _discardColor, _discardDepth ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.RenderTexture.DiscardContents!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResolveAntiAliasedSurface(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.ResolveAntiAliasedSurface( ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.RenderTexture _target = (UnityEngine.RenderTexture)translator.GetObject(L, 2, typeof(UnityEngine.RenderTexture)); + + gen_to_be_invoked.ResolveAntiAliasedSurface( _target ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.RenderTexture.ResolveAntiAliasedSurface!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetGlobalShaderProperty(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + + + + { + string _propertyName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SetGlobalShaderProperty( _propertyName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Create(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Create( ); + 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_Release(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Release( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsCreated(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsCreated( ); + 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_GenerateMips(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.GenerateMips( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ConvertToEquirect(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.RenderTexture _equirect = (UnityEngine.RenderTexture)translator.GetObject(L, 2, typeof(UnityEngine.RenderTexture)); + UnityEngine.Camera.MonoOrStereoscopicEye _eye;translator.Get(L, 3, out _eye); + + gen_to_be_invoked.ConvertToEquirect( _equirect, _eye ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.RenderTexture _equirect = (UnityEngine.RenderTexture)translator.GetObject(L, 2, typeof(UnityEngine.RenderTexture)); + + gen_to_be_invoked.ConvertToEquirect( _equirect ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.RenderTexture.ConvertToEquirect!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SupportsStencil_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.RenderTexture _rt = (UnityEngine.RenderTexture)translator.GetObject(L, 1, typeof(UnityEngine.RenderTexture)); + + var gen_ret = UnityEngine.RenderTexture.SupportsStencil( _rt ); + 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_ReleaseTemporary_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.RenderTexture _temp = (UnityEngine.RenderTexture)translator.GetObject(L, 1, typeof(UnityEngine.RenderTexture)); + + UnityEngine.RenderTexture.ReleaseTemporary( _temp ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_descriptor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.descriptor); + } 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); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)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); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)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 _g_get_dimension(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.dimension); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_graphicsFormat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.graphicsFormat); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_useMipMap(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.useMipMap); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sRGB(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.sRGB); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_vrUsage(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.vrUsage); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_memorylessMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.memorylessMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_format(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineRenderTextureFormat(L, gen_to_be_invoked.format); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_stencilFormat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.stencilFormat); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_depthStencilFormat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.depthStencilFormat); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_autoGenerateMips(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.autoGenerateMips); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_volumeDepth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.volumeDepth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_antiAliasing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.antiAliasing); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bindTextureMS(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.bindTextureMS); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enableRandomWrite(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.enableRandomWrite); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_useDynamicScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.useDynamicScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isPowerOfTwo(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isPowerOfTwo); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_active(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.RenderTexture.active); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_colorBuffer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.colorBuffer); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_depthBuffer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.depthBuffer); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_depth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.depth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_descriptor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + UnityEngine.RenderTextureDescriptor gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.descriptor = 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_width(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)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); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)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; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_dimension(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + UnityEngine.Rendering.TextureDimension gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.dimension = 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_graphicsFormat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + UnityEngine.Experimental.Rendering.GraphicsFormat gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.graphicsFormat = 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_useMipMap(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.useMipMap = 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_vrUsage(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + UnityEngine.VRTextureUsage gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.vrUsage = 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_memorylessMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + UnityEngine.RenderTextureMemoryless gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.memorylessMode = 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_format(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + UnityEngine.RenderTextureFormat gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.format = 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_stencilFormat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + UnityEngine.Experimental.Rendering.GraphicsFormat gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.stencilFormat = 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_depthStencilFormat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + UnityEngine.Experimental.Rendering.GraphicsFormat gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.depthStencilFormat = 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_autoGenerateMips(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.autoGenerateMips = 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_volumeDepth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.volumeDepth = 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_antiAliasing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.antiAliasing = 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_bindTextureMS(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.bindTextureMS = 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_enableRandomWrite(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.enableRandomWrite = 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_useDynamicScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.useDynamicScale = 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_isPowerOfTwo(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.isPowerOfTwo = 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_active(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + UnityEngine.RenderTexture.active = (UnityEngine.RenderTexture)translator.GetObject(L, 1, typeof(UnityEngine.RenderTexture)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_depth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RenderTexture gen_to_be_invoked = (UnityEngine.RenderTexture)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.depth = 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/UnityEngine_RendererWrap.cs b/Assets/XLua/Gen/UnityEngine_RendererWrap.cs new file mode 100644 index 000000000..0c72f4756 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_RendererWrap.cs @@ -0,0 +1,1250 @@ +#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 UnityEngineRendererWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Renderer); + Utils.BeginObjectRegister(type, L, translator, 0, 8, 31, 27); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetBounds", _m_ResetBounds); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetLocalBounds", _m_ResetLocalBounds); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasPropertyBlock", _m_HasPropertyBlock); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPropertyBlock", _m_SetPropertyBlock); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPropertyBlock", _m_GetPropertyBlock); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetMaterials", _m_GetMaterials); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSharedMaterials", _m_GetSharedMaterials); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetClosestReflectionProbes", _m_GetClosestReflectionProbes); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bounds", _g_get_bounds); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "localBounds", _g_get_localBounds); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "enabled", _g_get_enabled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isVisible", _g_get_isVisible); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "shadowCastingMode", _g_get_shadowCastingMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "receiveShadows", _g_get_receiveShadows); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "forceRenderingOff", _g_get_forceRenderingOff); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "staticShadowCaster", _g_get_staticShadowCaster); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "motionVectorGenerationMode", _g_get_motionVectorGenerationMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lightProbeUsage", _g_get_lightProbeUsage); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "reflectionProbeUsage", _g_get_reflectionProbeUsage); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "renderingLayerMask", _g_get_renderingLayerMask); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rendererPriority", _g_get_rendererPriority); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rayTracingMode", _g_get_rayTracingMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sortingLayerName", _g_get_sortingLayerName); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sortingLayerID", _g_get_sortingLayerID); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sortingOrder", _g_get_sortingOrder); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "allowOcclusionWhenDynamic", _g_get_allowOcclusionWhenDynamic); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isPartOfStaticBatch", _g_get_isPartOfStaticBatch); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "worldToLocalMatrix", _g_get_worldToLocalMatrix); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "localToWorldMatrix", _g_get_localToWorldMatrix); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lightProbeProxyVolumeOverride", _g_get_lightProbeProxyVolumeOverride); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "probeAnchor", _g_get_probeAnchor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lightmapIndex", _g_get_lightmapIndex); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "realtimeLightmapIndex", _g_get_realtimeLightmapIndex); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lightmapScaleOffset", _g_get_lightmapScaleOffset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "realtimeLightmapScaleOffset", _g_get_realtimeLightmapScaleOffset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "materials", _g_get_materials); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "material", _g_get_material); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sharedMaterial", _g_get_sharedMaterial); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sharedMaterials", _g_get_sharedMaterials); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "bounds", _s_set_bounds); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "localBounds", _s_set_localBounds); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "enabled", _s_set_enabled); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "shadowCastingMode", _s_set_shadowCastingMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "receiveShadows", _s_set_receiveShadows); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "forceRenderingOff", _s_set_forceRenderingOff); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "staticShadowCaster", _s_set_staticShadowCaster); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "motionVectorGenerationMode", _s_set_motionVectorGenerationMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "lightProbeUsage", _s_set_lightProbeUsage); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "reflectionProbeUsage", _s_set_reflectionProbeUsage); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "renderingLayerMask", _s_set_renderingLayerMask); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "rendererPriority", _s_set_rendererPriority); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "rayTracingMode", _s_set_rayTracingMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sortingLayerName", _s_set_sortingLayerName); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sortingLayerID", _s_set_sortingLayerID); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sortingOrder", _s_set_sortingOrder); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "allowOcclusionWhenDynamic", _s_set_allowOcclusionWhenDynamic); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "lightProbeProxyVolumeOverride", _s_set_lightProbeProxyVolumeOverride); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "probeAnchor", _s_set_probeAnchor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "lightmapIndex", _s_set_lightmapIndex); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "realtimeLightmapIndex", _s_set_realtimeLightmapIndex); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "lightmapScaleOffset", _s_set_lightmapScaleOffset); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "realtimeLightmapScaleOffset", _s_set_realtimeLightmapScaleOffset); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "materials", _s_set_materials); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "material", _s_set_material); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sharedMaterial", _s_set_sharedMaterial); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sharedMaterials", _s_set_sharedMaterials); + + + 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 UnityEngine.Renderer(); + 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 UnityEngine.Renderer constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetBounds(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ResetBounds( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetLocalBounds(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ResetLocalBounds( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_HasPropertyBlock(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.HasPropertyBlock( ); + 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_SetPropertyBlock(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 2, typeof(UnityEngine.MaterialPropertyBlock)); + + gen_to_be_invoked.SetPropertyBlock( _properties ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 2, typeof(UnityEngine.MaterialPropertyBlock)); + int _materialIndex = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetPropertyBlock( _properties, _materialIndex ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Renderer.SetPropertyBlock!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetPropertyBlock(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 2, typeof(UnityEngine.MaterialPropertyBlock)); + + gen_to_be_invoked.GetPropertyBlock( _properties ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.MaterialPropertyBlock _properties = (UnityEngine.MaterialPropertyBlock)translator.GetObject(L, 2, typeof(UnityEngine.MaterialPropertyBlock)); + int _materialIndex = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.GetPropertyBlock( _properties, _materialIndex ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Renderer.GetPropertyBlock!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetMaterials(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.List _m = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetMaterials( _m ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetSharedMaterials(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.List _m = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetSharedMaterials( _m ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetClosestReflectionProbes(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.List _result = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetClosestReflectionProbes( _result ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bounds(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineBounds(L, gen_to_be_invoked.bounds); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_localBounds(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineBounds(L, gen_to_be_invoked.localBounds); + } 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); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)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_isVisible(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isVisible); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_shadowCastingMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineRenderingShadowCastingMode(L, gen_to_be_invoked.shadowCastingMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_receiveShadows(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.receiveShadows); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_forceRenderingOff(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.forceRenderingOff); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_staticShadowCaster(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.staticShadowCaster); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_motionVectorGenerationMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.motionVectorGenerationMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lightProbeUsage(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.lightProbeUsage); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_reflectionProbeUsage(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.reflectionProbeUsage); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_renderingLayerMask(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushuint(L, gen_to_be_invoked.renderingLayerMask); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rendererPriority(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.rendererPriority); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rayTracingMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.rayTracingMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sortingLayerName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.sortingLayerName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sortingLayerID(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.sortingLayerID); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sortingOrder(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.sortingOrder); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_allowOcclusionWhenDynamic(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.allowOcclusionWhenDynamic); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isPartOfStaticBatch(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isPartOfStaticBatch); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_worldToLocalMatrix(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.worldToLocalMatrix); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_localToWorldMatrix(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.localToWorldMatrix); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lightProbeProxyVolumeOverride(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.lightProbeProxyVolumeOverride); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_probeAnchor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.probeAnchor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lightmapIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.lightmapIndex); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_realtimeLightmapIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.realtimeLightmapIndex); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lightmapScaleOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector4(L, gen_to_be_invoked.lightmapScaleOffset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_realtimeLightmapScaleOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector4(L, gen_to_be_invoked.realtimeLightmapScaleOffset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_materials(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.materials); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_material(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.material); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sharedMaterial(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.sharedMaterial); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sharedMaterials(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.sharedMaterials); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_bounds(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + UnityEngine.Bounds gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.bounds = 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_localBounds(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + UnityEngine.Bounds gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.localBounds = 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); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)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_shadowCastingMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + UnityEngine.Rendering.ShadowCastingMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.shadowCastingMode = 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_receiveShadows(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.receiveShadows = 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_forceRenderingOff(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.forceRenderingOff = 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_staticShadowCaster(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.staticShadowCaster = 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_motionVectorGenerationMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + UnityEngine.MotionVectorGenerationMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.motionVectorGenerationMode = 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_lightProbeUsage(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + UnityEngine.Rendering.LightProbeUsage gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.lightProbeUsage = 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_reflectionProbeUsage(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + UnityEngine.Rendering.ReflectionProbeUsage gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.reflectionProbeUsage = 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_renderingLayerMask(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.renderingLayerMask = LuaAPI.xlua_touint(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_rendererPriority(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.rendererPriority = 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_rayTracingMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + UnityEngine.Experimental.Rendering.RayTracingMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.rayTracingMode = 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_sortingLayerName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.sortingLayerName = 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_sortingLayerID(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.sortingLayerID = 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_sortingOrder(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.sortingOrder = 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_allowOcclusionWhenDynamic(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.allowOcclusionWhenDynamic = 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_lightProbeProxyVolumeOverride(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.lightProbeProxyVolumeOverride = (UnityEngine.GameObject)translator.GetObject(L, 2, typeof(UnityEngine.GameObject)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_probeAnchor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.probeAnchor = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_lightmapIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.lightmapIndex = 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_realtimeLightmapIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.realtimeLightmapIndex = 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_lightmapScaleOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + UnityEngine.Vector4 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.lightmapScaleOffset = 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_realtimeLightmapScaleOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + UnityEngine.Vector4 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.realtimeLightmapScaleOffset = 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_materials(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.materials = (UnityEngine.Material[])translator.GetObject(L, 2, typeof(UnityEngine.Material[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_material(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.material = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_sharedMaterial(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.sharedMaterial = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_sharedMaterials(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Renderer gen_to_be_invoked = (UnityEngine.Renderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.sharedMaterials = (UnityEngine.Material[])translator.GetObject(L, 2, typeof(UnityEngine.Material[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ResolutionWrap.cs b/Assets/XLua/Gen/UnityEngine_ResolutionWrap.cs new file mode 100644 index 000000000..52578a5d6 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ResolutionWrap.cs @@ -0,0 +1,212 @@ +#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 UnityEngineResolutionWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Resolution); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 3, 3); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "width", _g_get_width); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "height", _g_get_height); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "refreshRate", _g_get_refreshRate); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "width", _s_set_width); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "height", _s_set_height); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "refreshRate", _s_set_refreshRate); + + + 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) + { + translator.Push(L, default(UnityEngine.Resolution)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Resolution constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Resolution gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.ToString( ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_width(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Resolution gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + 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); + + UnityEngine.Resolution gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + 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 _g_get_refreshRate(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Resolution gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.refreshRate); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_width(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Resolution gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.width = LuaAPI.xlua_tointeger(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } 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); + + UnityEngine.Resolution gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.height = LuaAPI.xlua_tointeger(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_refreshRate(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Resolution gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.refreshRate = LuaAPI.xlua_tointeger(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ResourcesWrap.cs b/Assets/XLua/Gen/UnityEngine_ResourcesWrap.cs new file mode 100644 index 000000000..b5d403a42 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ResourcesWrap.cs @@ -0,0 +1,383 @@ +#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 UnityEngineResourcesWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Resources); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 10, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FindObjectsOfTypeAll", _m_FindObjectsOfTypeAll_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Load", _m_Load_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadAsync", _m_LoadAsync_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadAll", _m_LoadAll_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetBuiltinResource", _m_GetBuiltinResource_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "UnloadAsset", _m_UnloadAsset_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "UnloadUnusedAssets", _m_UnloadUnusedAssets_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "InstanceIDToObject", _m_InstanceIDToObject_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "InstanceIDToObjectList", _m_InstanceIDToObjectList_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 UnityEngine.Resources(); + 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 UnityEngine.Resources constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FindObjectsOfTypeAll_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.Type _type = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + + var gen_ret = UnityEngine.Resources.FindObjectsOfTypeAll( _type ); + 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_Load_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 _path = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.Resources.Load( _path ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _path = LuaAPI.lua_tostring(L, 1); + System.Type _systemTypeInstance = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + + var gen_ret = UnityEngine.Resources.Load( _path, _systemTypeInstance ); + 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 UnityEngine.Resources.Load!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadAsync_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 _path = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.Resources.LoadAsync( _path ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _path = LuaAPI.lua_tostring(L, 1); + System.Type _type = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + + var gen_ret = UnityEngine.Resources.LoadAsync( _path, _type ); + 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 UnityEngine.Resources.LoadAsync!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadAll_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 _path = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.Resources.LoadAll( _path ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _path = LuaAPI.lua_tostring(L, 1); + System.Type _systemTypeInstance = (System.Type)translator.GetObject(L, 2, typeof(System.Type)); + + var gen_ret = UnityEngine.Resources.LoadAll( _path, _systemTypeInstance ); + 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 UnityEngine.Resources.LoadAll!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetBuiltinResource_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.Type _type = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + string _path = LuaAPI.lua_tostring(L, 2); + + var gen_ret = UnityEngine.Resources.GetBuiltinResource( _type, _path ); + 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_UnloadAsset_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Object _assetToUnload = (UnityEngine.Object)translator.GetObject(L, 1, typeof(UnityEngine.Object)); + + UnityEngine.Resources.UnloadAsset( _assetToUnload ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UnloadUnusedAssets_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = UnityEngine.Resources.UnloadUnusedAssets( ); + 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_InstanceIDToObject_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + int _instanceID = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = UnityEngine.Resources.InstanceIDToObject( _instanceID ); + 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_InstanceIDToObjectList_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + Unity.Collections.NativeArray _instanceIDs;translator.Get(L, 1, out _instanceIDs); + System.Collections.Generic.List _objects = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + UnityEngine.Resources.InstanceIDToObjectList( _instanceIDs, _objects ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_RigidbodyWrap.cs b/Assets/XLua/Gen/UnityEngine_RigidbodyWrap.cs new file mode 100644 index 000000000..b14cf0f5d --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_RigidbodyWrap.cs @@ -0,0 +1,1620 @@ +#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 UnityEngineRigidbodyWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Rigidbody); + Utils.BeginObjectRegister(type, L, translator, 0, 19, 23, 22); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetDensity", _m_SetDensity); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "MovePosition", _m_MovePosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "MoveRotation", _m_MoveRotation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Sleep", _m_Sleep); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsSleeping", _m_IsSleeping); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "WakeUp", _m_WakeUp); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetCenterOfMass", _m_ResetCenterOfMass); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetInertiaTensor", _m_ResetInertiaTensor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetRelativePointVelocity", _m_GetRelativePointVelocity); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPointVelocity", _m_GetPointVelocity); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddForce", _m_AddForce); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddRelativeForce", _m_AddRelativeForce); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddTorque", _m_AddTorque); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddRelativeTorque", _m_AddRelativeTorque); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddForceAtPosition", _m_AddForceAtPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddExplosionForce", _m_AddExplosionForce); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClosestPointOnBounds", _m_ClosestPointOnBounds); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SweepTest", _m_SweepTest); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SweepTestAll", _m_SweepTestAll); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "velocity", _g_get_velocity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "angularVelocity", _g_get_angularVelocity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "drag", _g_get_drag); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "angularDrag", _g_get_angularDrag); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mass", _g_get_mass); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "useGravity", _g_get_useGravity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "maxDepenetrationVelocity", _g_get_maxDepenetrationVelocity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isKinematic", _g_get_isKinematic); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "freezeRotation", _g_get_freezeRotation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "constraints", _g_get_constraints); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "collisionDetectionMode", _g_get_collisionDetectionMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "centerOfMass", _g_get_centerOfMass); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "worldCenterOfMass", _g_get_worldCenterOfMass); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "inertiaTensorRotation", _g_get_inertiaTensorRotation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "inertiaTensor", _g_get_inertiaTensor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "detectCollisions", _g_get_detectCollisions); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "position", _g_get_position); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rotation", _g_get_rotation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "interpolation", _g_get_interpolation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "solverIterations", _g_get_solverIterations); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sleepThreshold", _g_get_sleepThreshold); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "maxAngularVelocity", _g_get_maxAngularVelocity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "solverVelocityIterations", _g_get_solverVelocityIterations); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "velocity", _s_set_velocity); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "angularVelocity", _s_set_angularVelocity); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "drag", _s_set_drag); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "angularDrag", _s_set_angularDrag); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "mass", _s_set_mass); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "useGravity", _s_set_useGravity); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "maxDepenetrationVelocity", _s_set_maxDepenetrationVelocity); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "isKinematic", _s_set_isKinematic); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "freezeRotation", _s_set_freezeRotation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "constraints", _s_set_constraints); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "collisionDetectionMode", _s_set_collisionDetectionMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "centerOfMass", _s_set_centerOfMass); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "inertiaTensorRotation", _s_set_inertiaTensorRotation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "inertiaTensor", _s_set_inertiaTensor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "detectCollisions", _s_set_detectCollisions); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "position", _s_set_position); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "rotation", _s_set_rotation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "interpolation", _s_set_interpolation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "solverIterations", _s_set_solverIterations); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sleepThreshold", _s_set_sleepThreshold); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "maxAngularVelocity", _s_set_maxAngularVelocity); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "solverVelocityIterations", _s_set_solverVelocityIterations); + + + 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 UnityEngine.Rigidbody(); + 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 UnityEngine.Rigidbody constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetDensity(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + + + + { + float _density = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.SetDensity( _density ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_MovePosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + + gen_to_be_invoked.MovePosition( _position ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_MoveRotation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Quaternion _rot;translator.Get(L, 2, out _rot); + + gen_to_be_invoked.MoveRotation( _rot ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Sleep(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Sleep( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsSleeping(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsSleeping( ); + 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_WakeUp(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.WakeUp( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetCenterOfMass(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ResetCenterOfMass( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ResetInertiaTensor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ResetInertiaTensor( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetRelativePointVelocity(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector3 _relativePoint;translator.Get(L, 2, out _relativePoint); + + var gen_ret = gen_to_be_invoked.GetRelativePointVelocity( _relativePoint ); + translator.PushUnityEngineVector3(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_GetPointVelocity(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector3 _worldPoint;translator.Get(L, 2, out _worldPoint); + + var gen_ret = gen_to_be_invoked.GetPointVelocity( _worldPoint ); + translator.PushUnityEngineVector3(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_AddForce(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.AddForce( _x, _y, _z ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _force;translator.Get(L, 2, out _force); + + gen_to_be_invoked.AddForce( _force ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + UnityEngine.ForceMode _mode;translator.Get(L, 5, out _mode); + + gen_to_be_invoked.AddForce( _x, _y, _z, _mode ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _force;translator.Get(L, 2, out _force); + UnityEngine.ForceMode _mode;translator.Get(L, 3, out _mode); + + gen_to_be_invoked.AddForce( _force, _mode ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Rigidbody.AddForce!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddRelativeForce(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.AddRelativeForce( _x, _y, _z ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _force;translator.Get(L, 2, out _force); + + gen_to_be_invoked.AddRelativeForce( _force ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + UnityEngine.ForceMode _mode;translator.Get(L, 5, out _mode); + + gen_to_be_invoked.AddRelativeForce( _x, _y, _z, _mode ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _force;translator.Get(L, 2, out _force); + UnityEngine.ForceMode _mode;translator.Get(L, 3, out _mode); + + gen_to_be_invoked.AddRelativeForce( _force, _mode ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Rigidbody.AddRelativeForce!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddTorque(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.AddTorque( _x, _y, _z ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _torque;translator.Get(L, 2, out _torque); + + gen_to_be_invoked.AddTorque( _torque ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + UnityEngine.ForceMode _mode;translator.Get(L, 5, out _mode); + + gen_to_be_invoked.AddTorque( _x, _y, _z, _mode ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _torque;translator.Get(L, 2, out _torque); + UnityEngine.ForceMode _mode;translator.Get(L, 3, out _mode); + + gen_to_be_invoked.AddTorque( _torque, _mode ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Rigidbody.AddTorque!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddRelativeTorque(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.AddRelativeTorque( _x, _y, _z ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _torque;translator.Get(L, 2, out _torque); + + gen_to_be_invoked.AddRelativeTorque( _torque ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + UnityEngine.ForceMode _mode;translator.Get(L, 5, out _mode); + + gen_to_be_invoked.AddRelativeTorque( _x, _y, _z, _mode ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _torque;translator.Get(L, 2, out _torque); + UnityEngine.ForceMode _mode;translator.Get(L, 3, out _mode); + + gen_to_be_invoked.AddRelativeTorque( _torque, _mode ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Rigidbody.AddRelativeTorque!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddForceAtPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _force;translator.Get(L, 2, out _force); + UnityEngine.Vector3 _position;translator.Get(L, 3, out _position); + + gen_to_be_invoked.AddForceAtPosition( _force, _position ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Vector3 _force;translator.Get(L, 2, out _force); + UnityEngine.Vector3 _position;translator.Get(L, 3, out _position); + UnityEngine.ForceMode _mode;translator.Get(L, 4, out _mode); + + gen_to_be_invoked.AddForceAtPosition( _force, _position, _mode ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Rigidbody.AddForceAtPosition!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddExplosionForce(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _explosionForce = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _explosionPosition;translator.Get(L, 3, out _explosionPosition); + float _explosionRadius = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.AddExplosionForce( _explosionForce, _explosionPosition, _explosionRadius ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + float _explosionForce = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _explosionPosition;translator.Get(L, 3, out _explosionPosition); + float _explosionRadius = (float)LuaAPI.lua_tonumber(L, 4); + float _upwardsModifier = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.AddExplosionForce( _explosionForce, _explosionPosition, _explosionRadius, _upwardsModifier ); + + + + return 0; + } + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)) + { + float _explosionForce = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _explosionPosition;translator.Get(L, 3, out _explosionPosition); + float _explosionRadius = (float)LuaAPI.lua_tonumber(L, 4); + float _upwardsModifier = (float)LuaAPI.lua_tonumber(L, 5); + UnityEngine.ForceMode _mode;translator.Get(L, 6, out _mode); + + gen_to_be_invoked.AddExplosionForce( _explosionForce, _explosionPosition, _explosionRadius, _upwardsModifier, _mode ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Rigidbody.AddExplosionForce!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClosestPointOnBounds(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + + var gen_ret = gen_to_be_invoked.ClosestPointOnBounds( _position ); + translator.PushUnityEngineVector3(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_SweepTest(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _direction;translator.Get(L, 2, out _direction); + UnityEngine.RaycastHit _hitInfo; + + var gen_ret = gen_to_be_invoked.SweepTest( _direction, out _hitInfo ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _direction;translator.Get(L, 2, out _direction); + UnityEngine.RaycastHit _hitInfo; + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.SweepTest( _direction, out _hitInfo, _maxDistance ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Vector3 _direction;translator.Get(L, 2, out _direction); + UnityEngine.RaycastHit _hitInfo; + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 4, out _queryTriggerInteraction); + + var gen_ret = gen_to_be_invoked.SweepTest( _direction, out _hitInfo, _maxDistance, _queryTriggerInteraction ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _hitInfo); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Rigidbody.SweepTest!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SweepTestAll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _direction;translator.Get(L, 2, out _direction); + + var gen_ret = gen_to_be_invoked.SweepTestAll( _direction ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _direction;translator.Get(L, 2, out _direction); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.SweepTestAll( _direction, _maxDistance ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Vector3 _direction;translator.Get(L, 2, out _direction); + float _maxDistance = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.QueryTriggerInteraction _queryTriggerInteraction;translator.Get(L, 4, out _queryTriggerInteraction); + + var gen_ret = gen_to_be_invoked.SweepTestAll( _direction, _maxDistance, _queryTriggerInteraction ); + 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 UnityEngine.Rigidbody.SweepTestAll!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_velocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.velocity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_angularVelocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.angularVelocity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_drag(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.drag); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_angularDrag(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.angularDrag); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mass(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.mass); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_useGravity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.useGravity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxDepenetrationVelocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.maxDepenetrationVelocity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isKinematic(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isKinematic); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_freezeRotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.freezeRotation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_constraints(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineRigidbodyConstraints(L, gen_to_be_invoked.constraints); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_collisionDetectionMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.collisionDetectionMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_centerOfMass(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.centerOfMass); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_worldCenterOfMass(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.worldCenterOfMass); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_inertiaTensorRotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineQuaternion(L, gen_to_be_invoked.inertiaTensorRotation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_inertiaTensor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.inertiaTensor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_detectCollisions(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.detectCollisions); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_position(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.position); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineQuaternion(L, gen_to_be_invoked.rotation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_interpolation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.interpolation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_solverIterations(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.solverIterations); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sleepThreshold(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.sleepThreshold); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxAngularVelocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.maxAngularVelocity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_solverVelocityIterations(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.solverVelocityIterations); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_velocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.velocity = 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_angularVelocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.angularVelocity = 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_drag(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.drag = (float)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_angularDrag(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.angularDrag = (float)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_mass(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.mass = (float)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_useGravity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.useGravity = 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_maxDepenetrationVelocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.maxDepenetrationVelocity = (float)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_isKinematic(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.isKinematic = 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_freezeRotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.freezeRotation = 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_constraints(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + UnityEngine.RigidbodyConstraints gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.constraints = 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_collisionDetectionMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + UnityEngine.CollisionDetectionMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.collisionDetectionMode = 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_centerOfMass(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.centerOfMass = 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_inertiaTensorRotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + UnityEngine.Quaternion gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.inertiaTensorRotation = 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_inertiaTensor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.inertiaTensor = 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_detectCollisions(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.detectCollisions = 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_position(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.position = 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_rotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + UnityEngine.Quaternion gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.rotation = 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_interpolation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + UnityEngine.RigidbodyInterpolation gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.interpolation = 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_solverIterations(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.solverIterations = 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_sleepThreshold(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.sleepThreshold = (float)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_maxAngularVelocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.maxAngularVelocity = (float)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_solverVelocityIterations(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Rigidbody gen_to_be_invoked = (UnityEngine.Rigidbody)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.solverVelocityIterations = 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/UnityEngine_RuntimeAnimatorControllerWrap.cs b/Assets/XLua/Gen/UnityEngine_RuntimeAnimatorControllerWrap.cs new file mode 100644 index 000000000..2f774da9d --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_RuntimeAnimatorControllerWrap.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 UnityEngineRuntimeAnimatorControllerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.RuntimeAnimatorController); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 1, 0); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "animationClips", _g_get_animationClips); + + + + 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, "UnityEngine.RuntimeAnimatorController does not have a constructor!"); + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_animationClips(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.RuntimeAnimatorController gen_to_be_invoked = (UnityEngine.RuntimeAnimatorController)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.animationClips); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_SceneManagement_SceneManagerWrap.cs b/Assets/XLua/Gen/UnityEngine_SceneManagement_SceneManagerWrap.cs new file mode 100644 index 000000000..a8c69804c --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_SceneManagement_SceneManagerWrap.cs @@ -0,0 +1,735 @@ +#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 UnityEngineSceneManagementSceneManagerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.SceneManagement.SceneManager); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 16, 2, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetActiveScene", _m_GetActiveScene_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetActiveScene", _m_SetActiveScene_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetSceneByPath", _m_GetSceneByPath_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetSceneByName", _m_GetSceneByName_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetSceneByBuildIndex", _m_GetSceneByBuildIndex_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetSceneAt", _m_GetSceneAt_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CreateScene", _m_CreateScene_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "MergeScenes", _m_MergeScenes_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "MoveGameObjectToScene", _m_MoveGameObjectToScene_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadScene", _m_LoadScene_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadSceneAsync", _m_LoadSceneAsync_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "UnloadSceneAsync", _m_UnloadSceneAsync_xlua_st_); + + Utils.RegisterFunc(L, Utils.CLS_IDX, "sceneLoaded", _e_sceneLoaded); + Utils.RegisterFunc(L, Utils.CLS_IDX, "sceneUnloaded", _e_sceneUnloaded); + Utils.RegisterFunc(L, Utils.CLS_IDX, "activeSceneChanged", _e_activeSceneChanged); + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "sceneCount", _g_get_sceneCount); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "sceneCountInBuildSettings", _g_get_sceneCountInBuildSettings); + + + + 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 UnityEngine.SceneManagement.SceneManager(); + 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 UnityEngine.SceneManagement.SceneManager constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetActiveScene_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = UnityEngine.SceneManagement.SceneManager.GetActiveScene( ); + 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_SetActiveScene_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.SceneManagement.Scene _scene;translator.Get(L, 1, out _scene); + + var gen_ret = UnityEngine.SceneManagement.SceneManager.SetActiveScene( _scene ); + 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_GetSceneByPath_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _scenePath = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.SceneManagement.SceneManager.GetSceneByPath( _scenePath ); + 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_GetSceneByName_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _name = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.SceneManagement.SceneManager.GetSceneByName( _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_GetSceneByBuildIndex_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + int _buildIndex = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = UnityEngine.SceneManagement.SceneManager.GetSceneByBuildIndex( _buildIndex ); + 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_GetSceneAt_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + int _index = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = UnityEngine.SceneManagement.SceneManager.GetSceneAt( _index ); + 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_CreateScene_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 _sceneName = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.SceneManagement.SceneManager.CreateScene( _sceneName ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _sceneName = LuaAPI.lua_tostring(L, 1); + UnityEngine.SceneManagement.CreateSceneParameters _parameters;translator.Get(L, 2, out _parameters); + + var gen_ret = UnityEngine.SceneManagement.SceneManager.CreateScene( _sceneName, _parameters ); + 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 UnityEngine.SceneManagement.SceneManager.CreateScene!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_MergeScenes_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.SceneManagement.Scene _sourceScene;translator.Get(L, 1, out _sourceScene); + UnityEngine.SceneManagement.Scene _destinationScene;translator.Get(L, 2, out _destinationScene); + + UnityEngine.SceneManagement.SceneManager.MergeScenes( _sourceScene, _destinationScene ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_MoveGameObjectToScene_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.GameObject _go = (UnityEngine.GameObject)translator.GetObject(L, 1, typeof(UnityEngine.GameObject)); + UnityEngine.SceneManagement.Scene _scene;translator.Get(L, 2, out _scene); + + UnityEngine.SceneManagement.SceneManager.MoveGameObjectToScene( _go, _scene ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadScene_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _sceneBuildIndex = LuaAPI.xlua_tointeger(L, 1); + + UnityEngine.SceneManagement.SceneManager.LoadScene( _sceneBuildIndex ); + + + + return 0; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _sceneName = LuaAPI.lua_tostring(L, 1); + + UnityEngine.SceneManagement.SceneManager.LoadScene( _sceneName ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + int _sceneBuildIndex = LuaAPI.xlua_tointeger(L, 1); + UnityEngine.SceneManagement.LoadSceneMode _mode;translator.Get(L, 2, out _mode); + + UnityEngine.SceneManagement.SceneManager.LoadScene( _sceneBuildIndex, _mode ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + int _sceneBuildIndex = LuaAPI.xlua_tointeger(L, 1); + UnityEngine.SceneManagement.LoadSceneParameters _parameters;translator.Get(L, 2, out _parameters); + + var gen_ret = UnityEngine.SceneManagement.SceneManager.LoadScene( _sceneBuildIndex, _parameters ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _sceneName = LuaAPI.lua_tostring(L, 1); + UnityEngine.SceneManagement.LoadSceneMode _mode;translator.Get(L, 2, out _mode); + + UnityEngine.SceneManagement.SceneManager.LoadScene( _sceneName, _mode ); + + + + 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 _sceneName = LuaAPI.lua_tostring(L, 1); + UnityEngine.SceneManagement.LoadSceneParameters _parameters;translator.Get(L, 2, out _parameters); + + var gen_ret = UnityEngine.SceneManagement.SceneManager.LoadScene( _sceneName, _parameters ); + 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 UnityEngine.SceneManagement.SceneManager.LoadScene!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadSceneAsync_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _sceneBuildIndex = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = UnityEngine.SceneManagement.SceneManager.LoadSceneAsync( _sceneBuildIndex ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _sceneName = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.SceneManagement.SceneManager.LoadSceneAsync( _sceneName ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + int _sceneBuildIndex = LuaAPI.xlua_tointeger(L, 1); + UnityEngine.SceneManagement.LoadSceneMode _mode;translator.Get(L, 2, out _mode); + + var gen_ret = UnityEngine.SceneManagement.SceneManager.LoadSceneAsync( _sceneBuildIndex, _mode ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + int _sceneBuildIndex = LuaAPI.xlua_tointeger(L, 1); + UnityEngine.SceneManagement.LoadSceneParameters _parameters;translator.Get(L, 2, out _parameters); + + var gen_ret = UnityEngine.SceneManagement.SceneManager.LoadSceneAsync( _sceneBuildIndex, _parameters ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _sceneName = LuaAPI.lua_tostring(L, 1); + UnityEngine.SceneManagement.LoadSceneMode _mode;translator.Get(L, 2, out _mode); + + var gen_ret = UnityEngine.SceneManagement.SceneManager.LoadSceneAsync( _sceneName, _mode ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _sceneName = LuaAPI.lua_tostring(L, 1); + UnityEngine.SceneManagement.LoadSceneParameters _parameters;translator.Get(L, 2, out _parameters); + + var gen_ret = UnityEngine.SceneManagement.SceneManager.LoadSceneAsync( _sceneName, _parameters ); + 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 UnityEngine.SceneManagement.SceneManager.LoadSceneAsync!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UnloadSceneAsync_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _sceneBuildIndex = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = UnityEngine.SceneManagement.SceneManager.UnloadSceneAsync( _sceneBuildIndex ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _sceneName = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.SceneManagement.SceneManager.UnloadSceneAsync( _sceneName ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + UnityEngine.SceneManagement.Scene _scene;translator.Get(L, 1, out _scene); + + var gen_ret = UnityEngine.SceneManagement.SceneManager.UnloadSceneAsync( _scene ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + int _sceneBuildIndex = LuaAPI.xlua_tointeger(L, 1); + UnityEngine.SceneManagement.UnloadSceneOptions _options;translator.Get(L, 2, out _options); + + var gen_ret = UnityEngine.SceneManagement.SceneManager.UnloadSceneAsync( _sceneBuildIndex, _options ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)) + { + string _sceneName = LuaAPI.lua_tostring(L, 1); + UnityEngine.SceneManagement.UnloadSceneOptions _options;translator.Get(L, 2, out _options); + + var gen_ret = UnityEngine.SceneManagement.SceneManager.UnloadSceneAsync( _sceneName, _options ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.SceneManagement.Scene _scene;translator.Get(L, 1, out _scene); + UnityEngine.SceneManagement.UnloadSceneOptions _options;translator.Get(L, 2, out _options); + + var gen_ret = UnityEngine.SceneManagement.SceneManager.UnloadSceneAsync( _scene, _options ); + 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 UnityEngine.SceneManagement.SceneManager.UnloadSceneAsync!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sceneCount(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SceneManagement.SceneManager.sceneCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sceneCountInBuildSettings(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SceneManagement.SceneManager.sceneCountInBuildSettings); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_sceneLoaded(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + UnityEngine.Events.UnityAction gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need UnityEngine.Events.UnityAction!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + UnityEngine.SceneManagement.SceneManager.sceneLoaded += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + UnityEngine.SceneManagement.SceneManager.sceneLoaded -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.SceneManagement.SceneManager.sceneLoaded!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_sceneUnloaded(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + UnityEngine.Events.UnityAction gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need UnityEngine.Events.UnityAction!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + UnityEngine.SceneManagement.SceneManager.sceneUnloaded += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + UnityEngine.SceneManagement.SceneManager.sceneUnloaded -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.SceneManagement.SceneManager.sceneUnloaded!"); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_activeSceneChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + UnityEngine.Events.UnityAction gen_delegate = translator.GetDelegate>(L, 2); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#2 need UnityEngine.Events.UnityAction!"); + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) { + UnityEngine.SceneManagement.SceneManager.activeSceneChanged += gen_delegate; + return 0; + } + + + if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) { + UnityEngine.SceneManagement.SceneManager.activeSceneChanged -= gen_delegate; + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.SceneManagement.SceneManager.activeSceneChanged!"); + } + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_SceneManagement_SceneWrap.cs b/Assets/XLua/Gen/UnityEngine_SceneManagement_SceneWrap.cs new file mode 100644 index 000000000..97cfd946c --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_SceneManagement_SceneWrap.cs @@ -0,0 +1,406 @@ +#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 UnityEngineSceneManagementSceneWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.SceneManagement.Scene); + Utils.BeginObjectRegister(type, L, translator, 1, 4, 8, 2); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__eq", __EqMeta); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsValid", _m_IsValid); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetRootGameObjects", _m_GetRootGameObjects); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashCode", _m_GetHashCode); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Equals", _m_Equals); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "handle", _g_get_handle); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "path", _g_get_path); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "name", _g_get_name); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isLoaded", _g_get_isLoaded); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "buildIndex", _g_get_buildIndex); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isDirty", _g_get_isDirty); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rootCount", _g_get_rootCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isSubScene", _g_get_isSubScene); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "name", _s_set_name); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "isSubScene", _s_set_isSubScene); + + + 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) + { + translator.Push(L, default(UnityEngine.SceneManagement.Scene)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.SceneManagement.Scene constructor!"); + + } + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __EqMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + UnityEngine.SceneManagement.Scene leftside;translator.Get(L, 1, out leftside); + UnityEngine.SceneManagement.Scene rightside;translator.Get(L, 2, out rightside); + + LuaAPI.lua_pushboolean(L, leftside == rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of == operator, need UnityEngine.SceneManagement.Scene!"); + + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsValid(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.SceneManagement.Scene gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.IsValid( ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetRootGameObjects(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.SceneManagement.Scene gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.GetRootGameObjects( ); + translator.Push(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.List _rootGameObjects = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.GetRootGameObjects( _rootGameObjects ); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.SceneManagement.Scene.GetRootGameObjects!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetHashCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.SceneManagement.Scene gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.GetHashCode( ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Equals(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.SceneManagement.Scene gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + object _other = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.Equals( _other ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_handle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SceneManagement.Scene gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.handle); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_path(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SceneManagement.Scene gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.path); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_name(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SceneManagement.Scene gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + 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_isLoaded(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SceneManagement.Scene gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isLoaded); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_buildIndex(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SceneManagement.Scene gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.buildIndex); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isDirty(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SceneManagement.Scene gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isDirty); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rootCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SceneManagement.Scene gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.rootCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isSubScene(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SceneManagement.Scene gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isSubScene); + } 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); + + UnityEngine.SceneManagement.Scene gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.name = LuaAPI.lua_tostring(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_isSubScene(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SceneManagement.Scene gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.isSubScene = LuaAPI.lua_toboolean(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ScreenWrap.cs b/Assets/XLua/Gen/UnityEngine_ScreenWrap.cs new file mode 100644 index 000000000..f73751f7c --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ScreenWrap.cs @@ -0,0 +1,576 @@ +#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 UnityEngineScreenWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Screen); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 4, 18, 9); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetResolution", _m_SetResolution_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetDisplayLayout", _m_GetDisplayLayout_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "MoveMainWindowTo", _m_MoveMainWindowTo_xlua_st_); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "width", _g_get_width); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "height", _g_get_height); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "dpi", _g_get_dpi); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "currentResolution", _g_get_currentResolution); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "resolutions", _g_get_resolutions); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "fullScreen", _g_get_fullScreen); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "fullScreenMode", _g_get_fullScreenMode); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "safeArea", _g_get_safeArea); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "cutouts", _g_get_cutouts); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "autorotateToPortrait", _g_get_autorotateToPortrait); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "autorotateToPortraitUpsideDown", _g_get_autorotateToPortraitUpsideDown); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "autorotateToLandscapeLeft", _g_get_autorotateToLandscapeLeft); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "autorotateToLandscapeRight", _g_get_autorotateToLandscapeRight); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "orientation", _g_get_orientation); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "sleepTimeout", _g_get_sleepTimeout); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "brightness", _g_get_brightness); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "mainWindowPosition", _g_get_mainWindowPosition); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "mainWindowDisplayInfo", _g_get_mainWindowDisplayInfo); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "fullScreen", _s_set_fullScreen); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "fullScreenMode", _s_set_fullScreenMode); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "autorotateToPortrait", _s_set_autorotateToPortrait); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "autorotateToPortraitUpsideDown", _s_set_autorotateToPortraitUpsideDown); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "autorotateToLandscapeLeft", _s_set_autorotateToLandscapeLeft); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "autorotateToLandscapeRight", _s_set_autorotateToLandscapeRight); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "orientation", _s_set_orientation); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "sleepTimeout", _s_set_sleepTimeout); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "brightness", _s_set_brightness); + + + 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 UnityEngine.Screen(); + 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 UnityEngine.Screen constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetResolution_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + int _width = LuaAPI.xlua_tointeger(L, 1); + int _height = LuaAPI.xlua_tointeger(L, 2); + bool _fullscreen = LuaAPI.lua_toboolean(L, 3); + + UnityEngine.Screen.SetResolution( _width, _height, _fullscreen ); + + + + return 0; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + int _width = LuaAPI.xlua_tointeger(L, 1); + int _height = LuaAPI.xlua_tointeger(L, 2); + bool _fullscreen = LuaAPI.lua_toboolean(L, 3); + int _preferredRefreshRate = LuaAPI.xlua_tointeger(L, 4); + + UnityEngine.Screen.SetResolution( _width, _height, _fullscreen, _preferredRefreshRate ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _width = LuaAPI.xlua_tointeger(L, 1); + int _height = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.FullScreenMode _fullscreenMode;translator.Get(L, 3, out _fullscreenMode); + + UnityEngine.Screen.SetResolution( _width, _height, _fullscreenMode ); + + + + return 0; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + int _width = LuaAPI.xlua_tointeger(L, 1); + int _height = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.FullScreenMode _fullscreenMode;translator.Get(L, 3, out _fullscreenMode); + int _preferredRefreshRate = LuaAPI.xlua_tointeger(L, 4); + + UnityEngine.Screen.SetResolution( _width, _height, _fullscreenMode, _preferredRefreshRate ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Screen.SetResolution!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetDisplayLayout_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.Collections.Generic.List _displayLayout = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + + UnityEngine.Screen.GetDisplayLayout( _displayLayout ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_MoveMainWindowTo_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.DisplayInfo _display;translator.Get(L, 1, out _display); + UnityEngine.Vector2Int _position;translator.Get(L, 2, out _position); + + var gen_ret = UnityEngine.Screen.MoveMainWindowTo( _display, _position ); + translator.Push(L, gen_ret); + translator.Push(L, _display); + translator.Update(L, 1, _display); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_width(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.Screen.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 { + + LuaAPI.xlua_pushinteger(L, UnityEngine.Screen.height); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_dpi(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Screen.dpi); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_currentResolution(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Screen.currentResolution); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_resolutions(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Screen.resolutions); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fullScreen(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Screen.fullScreen); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fullScreenMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Screen.fullScreenMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_safeArea(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Screen.safeArea); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cutouts(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Screen.cutouts); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_autorotateToPortrait(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Screen.autorotateToPortrait); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_autorotateToPortraitUpsideDown(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Screen.autorotateToPortraitUpsideDown); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_autorotateToLandscapeLeft(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Screen.autorotateToLandscapeLeft); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_autorotateToLandscapeRight(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Screen.autorotateToLandscapeRight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_orientation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Screen.orientation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sleepTimeout(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.Screen.sleepTimeout); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_brightness(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Screen.brightness); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mainWindowPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Screen.mainWindowPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mainWindowDisplayInfo(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Screen.mainWindowDisplayInfo); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_fullScreen(RealStatePtr L) + { + try { + + UnityEngine.Screen.fullScreen = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_fullScreenMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + UnityEngine.FullScreenMode gen_value;translator.Get(L, 1, out gen_value); + UnityEngine.Screen.fullScreenMode = 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_autorotateToPortrait(RealStatePtr L) + { + try { + + UnityEngine.Screen.autorotateToPortrait = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_autorotateToPortraitUpsideDown(RealStatePtr L) + { + try { + + UnityEngine.Screen.autorotateToPortraitUpsideDown = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_autorotateToLandscapeLeft(RealStatePtr L) + { + try { + + UnityEngine.Screen.autorotateToLandscapeLeft = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_autorotateToLandscapeRight(RealStatePtr L) + { + try { + + UnityEngine.Screen.autorotateToLandscapeRight = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_orientation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + UnityEngine.ScreenOrientation gen_value;translator.Get(L, 1, out gen_value); + UnityEngine.Screen.orientation = 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_sleepTimeout(RealStatePtr L) + { + try { + + UnityEngine.Screen.sleepTimeout = LuaAPI.xlua_tointeger(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_brightness(RealStatePtr L) + { + try { + + UnityEngine.Screen.brightness = (float)LuaAPI.lua_tonumber(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ScriptableObjectWrap.cs b/Assets/XLua/Gen/UnityEngine_ScriptableObjectWrap.cs new file mode 100644 index 000000000..bcd58e640 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ScriptableObjectWrap.cs @@ -0,0 +1,127 @@ +#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 UnityEngineScriptableObjectWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ScriptableObject); + 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, "CreateInstance", _m_CreateInstance_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 UnityEngine.ScriptableObject(); + 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 UnityEngine.ScriptableObject constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CreateInstance_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 _className = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.ScriptableObject.CreateInstance( _className ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + System.Type _type = (System.Type)translator.GetObject(L, 1, typeof(System.Type)); + + var gen_ret = UnityEngine.ScriptableObject.CreateInstance( _type ); + 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 UnityEngine.ScriptableObject.CreateInstance!"); + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ShaderVariantCollectionWrap.cs b/Assets/XLua/Gen/UnityEngine_ShaderVariantCollectionWrap.cs new file mode 100644 index 000000000..af3619fe5 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ShaderVariantCollectionWrap.cs @@ -0,0 +1,275 @@ +#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 UnityEngineShaderVariantCollectionWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ShaderVariantCollection); + Utils.BeginObjectRegister(type, L, translator, 0, 5, 3, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Add", _m_Add); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Remove", _m_Remove); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Contains", _m_Contains); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "WarmUp", _m_WarmUp); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "shaderCount", _g_get_shaderCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "variantCount", _g_get_variantCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isWarmedUp", _g_get_isWarmedUp); + + + + 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 UnityEngine.ShaderVariantCollection(); + 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 UnityEngine.ShaderVariantCollection constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Add(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ShaderVariantCollection gen_to_be_invoked = (UnityEngine.ShaderVariantCollection)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.ShaderVariantCollection.ShaderVariant _variant;translator.Get(L, 2, out _variant); + + var gen_ret = gen_to_be_invoked.Add( _variant ); + 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_Remove(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ShaderVariantCollection gen_to_be_invoked = (UnityEngine.ShaderVariantCollection)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.ShaderVariantCollection.ShaderVariant _variant;translator.Get(L, 2, out _variant); + + var gen_ret = gen_to_be_invoked.Remove( _variant ); + 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_Contains(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ShaderVariantCollection gen_to_be_invoked = (UnityEngine.ShaderVariantCollection)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.ShaderVariantCollection.ShaderVariant _variant;translator.Get(L, 2, out _variant); + + var gen_ret = gen_to_be_invoked.Contains( _variant ); + 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_Clear(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ShaderVariantCollection gen_to_be_invoked = (UnityEngine.ShaderVariantCollection)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Clear( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_WarmUp(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.ShaderVariantCollection gen_to_be_invoked = (UnityEngine.ShaderVariantCollection)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.WarmUp( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_shaderCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ShaderVariantCollection gen_to_be_invoked = (UnityEngine.ShaderVariantCollection)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.shaderCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_variantCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ShaderVariantCollection gen_to_be_invoked = (UnityEngine.ShaderVariantCollection)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.variantCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isWarmedUp(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ShaderVariantCollection gen_to_be_invoked = (UnityEngine.ShaderVariantCollection)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isWarmedUp); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ShaderVariantCollection_ShaderVariantWrap.cs b/Assets/XLua/Gen/UnityEngine_ShaderVariantCollection_ShaderVariantWrap.cs new file mode 100644 index 000000000..cd7ed1ad2 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ShaderVariantCollection_ShaderVariantWrap.cs @@ -0,0 +1,193 @@ +#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 UnityEngineShaderVariantCollectionShaderVariantWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.ShaderVariantCollection.ShaderVariant); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 3, 3); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "shader", _g_get_shader); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "passType", _g_get_passType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "keywords", _g_get_keywords); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "shader", _s_set_shader); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "passType", _s_set_passType); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "keywords", _s_set_keywords); + + + 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 && translator.Assignable(L, 2) && translator.Assignable(L, 3) && (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 4) || (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING))) + { + UnityEngine.Shader _shader = (UnityEngine.Shader)translator.GetObject(L, 2, typeof(UnityEngine.Shader)); + UnityEngine.Rendering.PassType _passType;translator.Get(L, 3, out _passType); + string[] _keywords = translator.GetParams(L, 4); + + var gen_ret = new UnityEngine.ShaderVariantCollection.ShaderVariant(_shader, _passType, _keywords); + translator.Push(L, gen_ret); + + return 1; + } + + if (LuaAPI.lua_gettop(L) == 1) + { + translator.Push(L, default(UnityEngine.ShaderVariantCollection.ShaderVariant)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.ShaderVariantCollection.ShaderVariant constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_shader(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ShaderVariantCollection.ShaderVariant gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.shader); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_passType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ShaderVariantCollection.ShaderVariant gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.passType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_keywords(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ShaderVariantCollection.ShaderVariant gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.keywords); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_shader(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ShaderVariantCollection.ShaderVariant gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.shader = (UnityEngine.Shader)translator.GetObject(L, 2, typeof(UnityEngine.Shader)); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_passType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ShaderVariantCollection.ShaderVariant gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.Rendering.PassType gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.passType = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_keywords(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.ShaderVariantCollection.ShaderVariant gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.keywords = (string[])translator.GetObject(L, 2, typeof(string[])); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_ShaderWrap.cs b/Assets/XLua/Gen/UnityEngine_ShaderWrap.cs new file mode 100644 index 000000000..44d2046bf --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_ShaderWrap.cs @@ -0,0 +1,2229 @@ +#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 UnityEngineShaderWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Shader); + Utils.BeginObjectRegister(type, L, translator, 0, 18, 6, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetDependency", _m_GetDependency); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPassCountInSubshader", _m_GetPassCountInSubshader); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindPassTagValue", _m_FindPassTagValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindSubshaderTagValue", _m_FindSubshaderTagValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPropertyCount", _m_GetPropertyCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindPropertyIndex", _m_FindPropertyIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPropertyName", _m_GetPropertyName); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPropertyNameId", _m_GetPropertyNameId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPropertyType", _m_GetPropertyType); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPropertyDescription", _m_GetPropertyDescription); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPropertyFlags", _m_GetPropertyFlags); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPropertyAttributes", _m_GetPropertyAttributes); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPropertyDefaultFloatValue", _m_GetPropertyDefaultFloatValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPropertyDefaultVectorValue", _m_GetPropertyDefaultVectorValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPropertyRangeLimits", _m_GetPropertyRangeLimits); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPropertyTextureDimension", _m_GetPropertyTextureDimension); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPropertyTextureDefaultName", _m_GetPropertyTextureDefaultName); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindTextureStack", _m_FindTextureStack); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "maximumLOD", _g_get_maximumLOD); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isSupported", _g_get_isSupported); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "keywordSpace", _g_get_keywordSpace); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "renderQueue", _g_get_renderQueue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "passCount", _g_get_passCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "subshaderCount", _g_get_subshaderCount); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "maximumLOD", _s_set_maximumLOD); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 30, 5, 3); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Find", _m_Find_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "EnableKeyword", _m_EnableKeyword_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "DisableKeyword", _m_DisableKeyword_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IsKeywordEnabled", _m_IsKeywordEnabled_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetKeyword", _m_SetKeyword_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "WarmupAllShaders", _m_WarmupAllShaders_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "PropertyToID", _m_PropertyToID_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetGlobalInt", _m_SetGlobalInt_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetGlobalFloat", _m_SetGlobalFloat_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetGlobalInteger", _m_SetGlobalInteger_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetGlobalVector", _m_SetGlobalVector_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetGlobalColor", _m_SetGlobalColor_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetGlobalMatrix", _m_SetGlobalMatrix_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetGlobalTexture", _m_SetGlobalTexture_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetGlobalBuffer", _m_SetGlobalBuffer_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetGlobalConstantBuffer", _m_SetGlobalConstantBuffer_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetGlobalFloatArray", _m_SetGlobalFloatArray_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetGlobalVectorArray", _m_SetGlobalVectorArray_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetGlobalMatrixArray", _m_SetGlobalMatrixArray_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetGlobalInt", _m_GetGlobalInt_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetGlobalFloat", _m_GetGlobalFloat_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetGlobalInteger", _m_GetGlobalInteger_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetGlobalVector", _m_GetGlobalVector_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetGlobalColor", _m_GetGlobalColor_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetGlobalMatrix", _m_GetGlobalMatrix_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetGlobalTexture", _m_GetGlobalTexture_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetGlobalFloatArray", _m_GetGlobalFloatArray_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetGlobalVectorArray", _m_GetGlobalVectorArray_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetGlobalMatrixArray", _m_GetGlobalMatrixArray_xlua_st_); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "maximumChunksOverride", _g_get_maximumChunksOverride); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "globalMaximumLOD", _g_get_globalMaximumLOD); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "globalRenderPipeline", _g_get_globalRenderPipeline); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "enabledGlobalKeywords", _g_get_enabledGlobalKeywords); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "globalKeywords", _g_get_globalKeywords); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "maximumChunksOverride", _s_set_maximumChunksOverride); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "globalMaximumLOD", _s_set_globalMaximumLOD); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "globalRenderPipeline", _s_set_globalRenderPipeline); + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "UnityEngine.Shader does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Find_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _name = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.Shader.Find( _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_EnableKeyword_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 _keyword = LuaAPI.lua_tostring(L, 1); + + UnityEngine.Shader.EnableKeyword( _keyword ); + + + + return 0; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + UnityEngine.Rendering.GlobalKeyword _keyword;translator.Get(L, 1, out _keyword); + + UnityEngine.Shader.EnableKeyword( _keyword ); + translator.Push(L, _keyword); + translator.Update(L, 1, _keyword); + + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Shader.EnableKeyword!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DisableKeyword_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 _keyword = LuaAPI.lua_tostring(L, 1); + + UnityEngine.Shader.DisableKeyword( _keyword ); + + + + return 0; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + UnityEngine.Rendering.GlobalKeyword _keyword;translator.Get(L, 1, out _keyword); + + UnityEngine.Shader.DisableKeyword( _keyword ); + translator.Push(L, _keyword); + translator.Update(L, 1, _keyword); + + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Shader.DisableKeyword!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsKeywordEnabled_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 _keyword = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.Shader.IsKeywordEnabled( _keyword ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + UnityEngine.Rendering.GlobalKeyword _keyword;translator.Get(L, 1, out _keyword); + + var gen_ret = UnityEngine.Shader.IsKeywordEnabled( _keyword ); + LuaAPI.lua_pushboolean(L, gen_ret); + translator.Push(L, _keyword); + translator.Update(L, 1, _keyword); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Shader.IsKeywordEnabled!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetKeyword_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Rendering.GlobalKeyword _keyword;translator.Get(L, 1, out _keyword); + bool _value = LuaAPI.lua_toboolean(L, 2); + + UnityEngine.Shader.SetKeyword( _keyword, _value ); + translator.Push(L, _keyword); + translator.Update(L, 1, _keyword); + + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_WarmupAllShaders_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + UnityEngine.Shader.WarmupAllShaders( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PropertyToID_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _name = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.Shader.PropertyToID( _name ); + 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_GetDependency(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Shader gen_to_be_invoked = (UnityEngine.Shader)translator.FastGetCSObj(L, 1); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetDependency( _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_GetPassCountInSubshader(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Shader gen_to_be_invoked = (UnityEngine.Shader)translator.FastGetCSObj(L, 1); + + + + { + int _subshaderIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetPassCountInSubshader( _subshaderIndex ); + 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_FindPassTagValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Shader gen_to_be_invoked = (UnityEngine.Shader)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + int _passIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Rendering.ShaderTagId _tagName;translator.Get(L, 3, out _tagName); + + var gen_ret = gen_to_be_invoked.FindPassTagValue( _passIndex, _tagName ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + int _subshaderIndex = LuaAPI.xlua_tointeger(L, 2); + int _passIndex = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.Rendering.ShaderTagId _tagName;translator.Get(L, 4, out _tagName); + + var gen_ret = gen_to_be_invoked.FindPassTagValue( _subshaderIndex, _passIndex, _tagName ); + 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 UnityEngine.Shader.FindPassTagValue!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FindSubshaderTagValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Shader gen_to_be_invoked = (UnityEngine.Shader)translator.FastGetCSObj(L, 1); + + + + { + int _subshaderIndex = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.Rendering.ShaderTagId _tagName;translator.Get(L, 3, out _tagName); + + var gen_ret = gen_to_be_invoked.FindSubshaderTagValue( _subshaderIndex, _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_SetGlobalInt_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + int _value = LuaAPI.xlua_tointeger(L, 2); + + UnityEngine.Shader.SetGlobalInt( _nameID, _value ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + string _name = LuaAPI.lua_tostring(L, 1); + int _value = LuaAPI.xlua_tointeger(L, 2); + + UnityEngine.Shader.SetGlobalInt( _name, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Shader.SetGlobalInt!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetGlobalFloat_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + float _value = (float)LuaAPI.lua_tonumber(L, 2); + + UnityEngine.Shader.SetGlobalFloat( _nameID, _value ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + string _name = LuaAPI.lua_tostring(L, 1); + float _value = (float)LuaAPI.lua_tonumber(L, 2); + + UnityEngine.Shader.SetGlobalFloat( _name, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Shader.SetGlobalFloat!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetGlobalInteger_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + int _value = LuaAPI.xlua_tointeger(L, 2); + + UnityEngine.Shader.SetGlobalInteger( _nameID, _value ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + string _name = LuaAPI.lua_tostring(L, 1); + int _value = LuaAPI.xlua_tointeger(L, 2); + + UnityEngine.Shader.SetGlobalInteger( _name, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Shader.SetGlobalInteger!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetGlobalVector_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + UnityEngine.Vector4 _value;translator.Get(L, 2, out _value); + + UnityEngine.Shader.SetGlobalVector( _nameID, _value ); + + + + 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 _name = LuaAPI.lua_tostring(L, 1); + UnityEngine.Vector4 _value;translator.Get(L, 2, out _value); + + UnityEngine.Shader.SetGlobalVector( _name, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Shader.SetGlobalVector!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetGlobalColor_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + UnityEngine.Color _value;translator.Get(L, 2, out _value); + + UnityEngine.Shader.SetGlobalColor( _nameID, _value ); + + + + 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 _name = LuaAPI.lua_tostring(L, 1); + UnityEngine.Color _value;translator.Get(L, 2, out _value); + + UnityEngine.Shader.SetGlobalColor( _name, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Shader.SetGlobalColor!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetGlobalMatrix_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + UnityEngine.Matrix4x4 _value;translator.Get(L, 2, out _value); + + UnityEngine.Shader.SetGlobalMatrix( _nameID, _value ); + + + + 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 _name = LuaAPI.lua_tostring(L, 1); + UnityEngine.Matrix4x4 _value;translator.Get(L, 2, out _value); + + UnityEngine.Shader.SetGlobalMatrix( _name, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Shader.SetGlobalMatrix!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetGlobalTexture_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + UnityEngine.Texture _value = (UnityEngine.Texture)translator.GetObject(L, 2, typeof(UnityEngine.Texture)); + + UnityEngine.Shader.SetGlobalTexture( _nameID, _value ); + + + + 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 _name = LuaAPI.lua_tostring(L, 1); + UnityEngine.Texture _value = (UnityEngine.Texture)translator.GetObject(L, 2, typeof(UnityEngine.Texture)); + + UnityEngine.Shader.SetGlobalTexture( _name, _value ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + UnityEngine.RenderTexture _value = (UnityEngine.RenderTexture)translator.GetObject(L, 2, typeof(UnityEngine.RenderTexture)); + UnityEngine.Rendering.RenderTextureSubElement _element;translator.Get(L, 3, out _element); + + UnityEngine.Shader.SetGlobalTexture( _nameID, _value, _element ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + string _name = LuaAPI.lua_tostring(L, 1); + UnityEngine.RenderTexture _value = (UnityEngine.RenderTexture)translator.GetObject(L, 2, typeof(UnityEngine.RenderTexture)); + UnityEngine.Rendering.RenderTextureSubElement _element;translator.Get(L, 3, out _element); + + UnityEngine.Shader.SetGlobalTexture( _name, _value, _element ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Shader.SetGlobalTexture!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetGlobalBuffer_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + UnityEngine.ComputeBuffer _value = (UnityEngine.ComputeBuffer)translator.GetObject(L, 2, typeof(UnityEngine.ComputeBuffer)); + + UnityEngine.Shader.SetGlobalBuffer( _nameID, _value ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + UnityEngine.GraphicsBuffer _value = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 2, typeof(UnityEngine.GraphicsBuffer)); + + UnityEngine.Shader.SetGlobalBuffer( _nameID, _value ); + + + + 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 _name = LuaAPI.lua_tostring(L, 1); + UnityEngine.ComputeBuffer _value = (UnityEngine.ComputeBuffer)translator.GetObject(L, 2, typeof(UnityEngine.ComputeBuffer)); + + UnityEngine.Shader.SetGlobalBuffer( _name, _value ); + + + + 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 _name = LuaAPI.lua_tostring(L, 1); + UnityEngine.GraphicsBuffer _value = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 2, typeof(UnityEngine.GraphicsBuffer)); + + UnityEngine.Shader.SetGlobalBuffer( _name, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Shader.SetGlobalBuffer!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetGlobalConstantBuffer_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + UnityEngine.ComputeBuffer _value = (UnityEngine.ComputeBuffer)translator.GetObject(L, 2, typeof(UnityEngine.ComputeBuffer)); + int _offset = LuaAPI.xlua_tointeger(L, 3); + int _size = LuaAPI.xlua_tointeger(L, 4); + + UnityEngine.Shader.SetGlobalConstantBuffer( _nameID, _value, _offset, _size ); + + + + return 0; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + UnityEngine.GraphicsBuffer _value = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 2, typeof(UnityEngine.GraphicsBuffer)); + int _offset = LuaAPI.xlua_tointeger(L, 3); + int _size = LuaAPI.xlua_tointeger(L, 4); + + UnityEngine.Shader.SetGlobalConstantBuffer( _nameID, _value, _offset, _size ); + + + + return 0; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + string _name = LuaAPI.lua_tostring(L, 1); + UnityEngine.ComputeBuffer _value = (UnityEngine.ComputeBuffer)translator.GetObject(L, 2, typeof(UnityEngine.ComputeBuffer)); + int _offset = LuaAPI.xlua_tointeger(L, 3); + int _size = LuaAPI.xlua_tointeger(L, 4); + + UnityEngine.Shader.SetGlobalConstantBuffer( _name, _value, _offset, _size ); + + + + return 0; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + string _name = LuaAPI.lua_tostring(L, 1); + UnityEngine.GraphicsBuffer _value = (UnityEngine.GraphicsBuffer)translator.GetObject(L, 2, typeof(UnityEngine.GraphicsBuffer)); + int _offset = LuaAPI.xlua_tointeger(L, 3); + int _size = LuaAPI.xlua_tointeger(L, 4); + + UnityEngine.Shader.SetGlobalConstantBuffer( _name, _value, _offset, _size ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Shader.SetGlobalConstantBuffer!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetGlobalFloatArray_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable>(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + UnityEngine.Shader.SetGlobalFloatArray( _nameID, _values ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + float[] _values = (float[])translator.GetObject(L, 2, typeof(float[])); + + UnityEngine.Shader.SetGlobalFloatArray( _nameID, _values ); + + + + 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 _name = LuaAPI.lua_tostring(L, 1); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + UnityEngine.Shader.SetGlobalFloatArray( _name, _values ); + + + + 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 _name = LuaAPI.lua_tostring(L, 1); + float[] _values = (float[])translator.GetObject(L, 2, typeof(float[])); + + UnityEngine.Shader.SetGlobalFloatArray( _name, _values ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Shader.SetGlobalFloatArray!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetGlobalVectorArray_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable>(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + UnityEngine.Shader.SetGlobalVectorArray( _nameID, _values ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + UnityEngine.Vector4[] _values = (UnityEngine.Vector4[])translator.GetObject(L, 2, typeof(UnityEngine.Vector4[])); + + UnityEngine.Shader.SetGlobalVectorArray( _nameID, _values ); + + + + 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 _name = LuaAPI.lua_tostring(L, 1); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + UnityEngine.Shader.SetGlobalVectorArray( _name, _values ); + + + + 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 _name = LuaAPI.lua_tostring(L, 1); + UnityEngine.Vector4[] _values = (UnityEngine.Vector4[])translator.GetObject(L, 2, typeof(UnityEngine.Vector4[])); + + UnityEngine.Shader.SetGlobalVectorArray( _name, _values ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Shader.SetGlobalVectorArray!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetGlobalMatrixArray_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable>(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + UnityEngine.Shader.SetGlobalMatrixArray( _nameID, _values ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + UnityEngine.Matrix4x4[] _values = (UnityEngine.Matrix4x4[])translator.GetObject(L, 2, typeof(UnityEngine.Matrix4x4[])); + + UnityEngine.Shader.SetGlobalMatrixArray( _nameID, _values ); + + + + 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 _name = LuaAPI.lua_tostring(L, 1); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + UnityEngine.Shader.SetGlobalMatrixArray( _name, _values ); + + + + 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 _name = LuaAPI.lua_tostring(L, 1); + UnityEngine.Matrix4x4[] _values = (UnityEngine.Matrix4x4[])translator.GetObject(L, 2, typeof(UnityEngine.Matrix4x4[])); + + UnityEngine.Shader.SetGlobalMatrixArray( _name, _values ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Shader.SetGlobalMatrixArray!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetGlobalInt_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = UnityEngine.Shader.GetGlobalInt( _nameID ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.Shader.GetGlobalInt( _name ); + LuaAPI.xlua_pushinteger(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 UnityEngine.Shader.GetGlobalInt!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetGlobalFloat_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = UnityEngine.Shader.GetGlobalFloat( _nameID ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.Shader.GetGlobalFloat( _name ); + LuaAPI.lua_pushnumber(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 UnityEngine.Shader.GetGlobalFloat!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetGlobalInteger_xlua_st_(RealStatePtr L) + { + try { + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = UnityEngine.Shader.GetGlobalInteger( _nameID ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.Shader.GetGlobalInteger( _name ); + LuaAPI.xlua_pushinteger(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 UnityEngine.Shader.GetGlobalInteger!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetGlobalVector_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = UnityEngine.Shader.GetGlobalVector( _nameID ); + translator.PushUnityEngineVector4(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.Shader.GetGlobalVector( _name ); + translator.PushUnityEngineVector4(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 UnityEngine.Shader.GetGlobalVector!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetGlobalColor_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = UnityEngine.Shader.GetGlobalColor( _nameID ); + translator.PushUnityEngineColor(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.Shader.GetGlobalColor( _name ); + translator.PushUnityEngineColor(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 UnityEngine.Shader.GetGlobalColor!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetGlobalMatrix_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = UnityEngine.Shader.GetGlobalMatrix( _nameID ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.Shader.GetGlobalMatrix( _name ); + 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 UnityEngine.Shader.GetGlobalMatrix!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetGlobalTexture_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = UnityEngine.Shader.GetGlobalTexture( _nameID ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.Shader.GetGlobalTexture( _name ); + 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 UnityEngine.Shader.GetGlobalTexture!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetGlobalFloatArray_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = UnityEngine.Shader.GetGlobalFloatArray( _nameID ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.Shader.GetGlobalFloatArray( _name ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable>(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + UnityEngine.Shader.GetGlobalFloatArray( _nameID, _values ); + + + + 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 _name = LuaAPI.lua_tostring(L, 1); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + UnityEngine.Shader.GetGlobalFloatArray( _name, _values ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Shader.GetGlobalFloatArray!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetGlobalVectorArray_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = UnityEngine.Shader.GetGlobalVectorArray( _nameID ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.Shader.GetGlobalVectorArray( _name ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable>(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + UnityEngine.Shader.GetGlobalVectorArray( _nameID, _values ); + + + + 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 _name = LuaAPI.lua_tostring(L, 1); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + UnityEngine.Shader.GetGlobalVectorArray( _name, _values ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Shader.GetGlobalVectorArray!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetGlobalMatrixArray_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + + var gen_ret = UnityEngine.Shader.GetGlobalMatrixArray( _nameID ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) + { + string _name = LuaAPI.lua_tostring(L, 1); + + var gen_ret = UnityEngine.Shader.GetGlobalMatrixArray( _name ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable>(L, 2)) + { + int _nameID = LuaAPI.xlua_tointeger(L, 1); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + UnityEngine.Shader.GetGlobalMatrixArray( _nameID, _values ); + + + + 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 _name = LuaAPI.lua_tostring(L, 1); + System.Collections.Generic.List _values = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + UnityEngine.Shader.GetGlobalMatrixArray( _name, _values ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Shader.GetGlobalMatrixArray!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetPropertyCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Shader gen_to_be_invoked = (UnityEngine.Shader)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetPropertyCount( ); + 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_FindPropertyIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Shader gen_to_be_invoked = (UnityEngine.Shader)translator.FastGetCSObj(L, 1); + + + + { + string _propertyName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.FindPropertyIndex( _propertyName ); + 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_GetPropertyName(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Shader gen_to_be_invoked = (UnityEngine.Shader)translator.FastGetCSObj(L, 1); + + + + { + int _propertyIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetPropertyName( _propertyIndex ); + 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 _m_GetPropertyNameId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Shader gen_to_be_invoked = (UnityEngine.Shader)translator.FastGetCSObj(L, 1); + + + + { + int _propertyIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetPropertyNameId( _propertyIndex ); + 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_GetPropertyType(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Shader gen_to_be_invoked = (UnityEngine.Shader)translator.FastGetCSObj(L, 1); + + + + { + int _propertyIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetPropertyType( _propertyIndex ); + 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_GetPropertyDescription(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Shader gen_to_be_invoked = (UnityEngine.Shader)translator.FastGetCSObj(L, 1); + + + + { + int _propertyIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetPropertyDescription( _propertyIndex ); + 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 _m_GetPropertyFlags(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Shader gen_to_be_invoked = (UnityEngine.Shader)translator.FastGetCSObj(L, 1); + + + + { + int _propertyIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetPropertyFlags( _propertyIndex ); + 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_GetPropertyAttributes(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Shader gen_to_be_invoked = (UnityEngine.Shader)translator.FastGetCSObj(L, 1); + + + + { + int _propertyIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetPropertyAttributes( _propertyIndex ); + 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_GetPropertyDefaultFloatValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Shader gen_to_be_invoked = (UnityEngine.Shader)translator.FastGetCSObj(L, 1); + + + + { + int _propertyIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetPropertyDefaultFloatValue( _propertyIndex ); + LuaAPI.lua_pushnumber(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_GetPropertyDefaultVectorValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Shader gen_to_be_invoked = (UnityEngine.Shader)translator.FastGetCSObj(L, 1); + + + + { + int _propertyIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetPropertyDefaultVectorValue( _propertyIndex ); + translator.PushUnityEngineVector4(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_GetPropertyRangeLimits(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Shader gen_to_be_invoked = (UnityEngine.Shader)translator.FastGetCSObj(L, 1); + + + + { + int _propertyIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetPropertyRangeLimits( _propertyIndex ); + translator.PushUnityEngineVector2(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_GetPropertyTextureDimension(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Shader gen_to_be_invoked = (UnityEngine.Shader)translator.FastGetCSObj(L, 1); + + + + { + int _propertyIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetPropertyTextureDimension( _propertyIndex ); + 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_GetPropertyTextureDefaultName(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Shader gen_to_be_invoked = (UnityEngine.Shader)translator.FastGetCSObj(L, 1); + + + + { + int _propertyIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetPropertyTextureDefaultName( _propertyIndex ); + 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 _m_FindTextureStack(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Shader gen_to_be_invoked = (UnityEngine.Shader)translator.FastGetCSObj(L, 1); + + + + { + int _propertyIndex = LuaAPI.xlua_tointeger(L, 2); + string _stackName; + int _layerIndex; + + var gen_ret = gen_to_be_invoked.FindTextureStack( _propertyIndex, out _stackName, out _layerIndex ); + LuaAPI.lua_pushboolean(L, gen_ret); + LuaAPI.lua_pushstring(L, _stackName); + + LuaAPI.xlua_pushinteger(L, _layerIndex); + + + + + return 3; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maximumChunksOverride(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.Shader.maximumChunksOverride); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maximumLOD(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Shader gen_to_be_invoked = (UnityEngine.Shader)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.maximumLOD); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_globalMaximumLOD(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.Shader.globalMaximumLOD); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isSupported(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Shader gen_to_be_invoked = (UnityEngine.Shader)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isSupported); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_globalRenderPipeline(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, UnityEngine.Shader.globalRenderPipeline); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_enabledGlobalKeywords(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Shader.enabledGlobalKeywords); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_globalKeywords(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Shader.globalKeywords); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_keywordSpace(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Shader gen_to_be_invoked = (UnityEngine.Shader)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.keywordSpace); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_renderQueue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Shader gen_to_be_invoked = (UnityEngine.Shader)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.renderQueue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_passCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Shader gen_to_be_invoked = (UnityEngine.Shader)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.passCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_subshaderCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Shader gen_to_be_invoked = (UnityEngine.Shader)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.subshaderCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_maximumChunksOverride(RealStatePtr L) + { + try { + + UnityEngine.Shader.maximumChunksOverride = LuaAPI.xlua_tointeger(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_maximumLOD(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Shader gen_to_be_invoked = (UnityEngine.Shader)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.maximumLOD = 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_globalMaximumLOD(RealStatePtr L) + { + try { + + UnityEngine.Shader.globalMaximumLOD = LuaAPI.xlua_tointeger(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_globalRenderPipeline(RealStatePtr L) + { + try { + + UnityEngine.Shader.globalRenderPipeline = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_SignInWithApple_SignInWithAppleEventWrap.cs b/Assets/XLua/Gen/UnityEngine_SignInWithApple_SignInWithAppleEventWrap.cs new file mode 100644 index 000000000..0385cde1b --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_SignInWithApple_SignInWithAppleEventWrap.cs @@ -0,0 +1,84 @@ +#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 UnityEngineSignInWithAppleSignInWithAppleEventWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.SignInWithApple.SignInWithAppleEvent); + 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) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new UnityEngine.SignInWithApple.SignInWithAppleEvent(); + 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 UnityEngine.SignInWithApple.SignInWithAppleEvent constructor!"); + + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_SignInWithApple_SignInWithAppleWrap.cs b/Assets/XLua/Gen/UnityEngine_SignInWithApple_SignInWithAppleWrap.cs new file mode 100644 index 000000000..0bf184585 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_SignInWithApple_SignInWithAppleWrap.cs @@ -0,0 +1,291 @@ +#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 UnityEngineSignInWithAppleSignInWithAppleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.SignInWithApple.SignInWithApple); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 3, 3); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetCredentialState", _m_GetCredentialState); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Login", _m_Login); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Update", _m_Update); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onLogin", _g_get_onLogin); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onCredentialState", _g_get_onCredentialState); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onError", _g_get_onError); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onLogin", _s_set_onLogin); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onCredentialState", _s_set_onCredentialState); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onError", _s_set_onError); + + + 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 UnityEngine.SignInWithApple.SignInWithApple(); + 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 UnityEngine.SignInWithApple.SignInWithApple constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetCredentialState(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.SignInWithApple.SignInWithApple gen_to_be_invoked = (UnityEngine.SignInWithApple.SignInWithApple)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _userID = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.GetCredentialState( _userID ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _userID = LuaAPI.lua_tostring(L, 2); + UnityEngine.SignInWithApple.SignInWithApple.Callback _callback = translator.GetDelegate(L, 3); + + gen_to_be_invoked.GetCredentialState( _userID, _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.SignInWithApple.SignInWithApple.GetCredentialState!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Login(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.SignInWithApple.SignInWithApple gen_to_be_invoked = (UnityEngine.SignInWithApple.SignInWithApple)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.Login( ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.SignInWithApple.SignInWithApple.Callback _callback = translator.GetDelegate(L, 2); + + gen_to_be_invoked.Login( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.SignInWithApple.SignInWithApple.Login!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Update(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.SignInWithApple.SignInWithApple gen_to_be_invoked = (UnityEngine.SignInWithApple.SignInWithApple)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Update( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onLogin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SignInWithApple.SignInWithApple gen_to_be_invoked = (UnityEngine.SignInWithApple.SignInWithApple)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onLogin); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onCredentialState(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SignInWithApple.SignInWithApple gen_to_be_invoked = (UnityEngine.SignInWithApple.SignInWithApple)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onCredentialState); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onError(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SignInWithApple.SignInWithApple gen_to_be_invoked = (UnityEngine.SignInWithApple.SignInWithApple)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onError); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_onLogin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SignInWithApple.SignInWithApple gen_to_be_invoked = (UnityEngine.SignInWithApple.SignInWithApple)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onLogin = (UnityEngine.SignInWithApple.SignInWithAppleEvent)translator.GetObject(L, 2, typeof(UnityEngine.SignInWithApple.SignInWithAppleEvent)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_onCredentialState(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SignInWithApple.SignInWithApple gen_to_be_invoked = (UnityEngine.SignInWithApple.SignInWithApple)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onCredentialState = (UnityEngine.SignInWithApple.SignInWithAppleEvent)translator.GetObject(L, 2, typeof(UnityEngine.SignInWithApple.SignInWithAppleEvent)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_onError(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SignInWithApple.SignInWithApple gen_to_be_invoked = (UnityEngine.SignInWithApple.SignInWithApple)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onError = (UnityEngine.SignInWithApple.SignInWithAppleEvent)translator.GetObject(L, 2, typeof(UnityEngine.SignInWithApple.SignInWithAppleEvent)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_SignInWithApple_SignInWithApple_CallbackArgsWrap.cs b/Assets/XLua/Gen/UnityEngine_SignInWithApple_SignInWithApple_CallbackArgsWrap.cs new file mode 100644 index 000000000..ead6c3deb --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_SignInWithApple_SignInWithApple_CallbackArgsWrap.cs @@ -0,0 +1,183 @@ +#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 UnityEngineSignInWithAppleSignInWithAppleCallbackArgsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.SignInWithApple.SignInWithApple.CallbackArgs); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 3, 3); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "credentialState", _g_get_credentialState); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "userInfo", _g_get_userInfo); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "error", _g_get_error); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "credentialState", _s_set_credentialState); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "userInfo", _s_set_userInfo); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "error", _s_set_error); + + + 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) + { + translator.Push(L, default(UnityEngine.SignInWithApple.SignInWithApple.CallbackArgs)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.SignInWithApple.SignInWithApple.CallbackArgs constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_credentialState(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SignInWithApple.SignInWithApple.CallbackArgs gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.credentialState); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_userInfo(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SignInWithApple.SignInWithApple.CallbackArgs gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.userInfo); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_error(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SignInWithApple.SignInWithApple.CallbackArgs gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.error); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_credentialState(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SignInWithApple.SignInWithApple.CallbackArgs gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.SignInWithApple.UserCredentialState gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.credentialState = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_userInfo(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SignInWithApple.SignInWithApple.CallbackArgs gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.SignInWithApple.UserInfo gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.userInfo = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_error(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SignInWithApple.SignInWithApple.CallbackArgs gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.error = LuaAPI.lua_tostring(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_SignInWithApple_UserInfoWrap.cs b/Assets/XLua/Gen/UnityEngine_SignInWithApple_UserInfoWrap.cs new file mode 100644 index 000000000..0321bbf90 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_SignInWithApple_UserInfoWrap.cs @@ -0,0 +1,281 @@ +#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 UnityEngineSignInWithAppleUserInfoWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.SignInWithApple.UserInfo); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 6, 6); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "userId", _g_get_userId); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "email", _g_get_email); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "displayName", _g_get_displayName); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "idToken", _g_get_idToken); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "error", _g_get_error); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "userDetectionStatus", _g_get_userDetectionStatus); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "userId", _s_set_userId); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "email", _s_set_email); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "displayName", _s_set_displayName); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "idToken", _s_set_idToken); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "error", _s_set_error); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "userDetectionStatus", _s_set_userDetectionStatus); + + + 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) + { + translator.Push(L, default(UnityEngine.SignInWithApple.UserInfo)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.SignInWithApple.UserInfo constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_userId(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SignInWithApple.UserInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + 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_email(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SignInWithApple.UserInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.email); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_displayName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SignInWithApple.UserInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.displayName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_idToken(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SignInWithApple.UserInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.idToken); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_error(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SignInWithApple.UserInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.error); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_userDetectionStatus(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SignInWithApple.UserInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.Push(L, gen_to_be_invoked.userDetectionStatus); + } 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); + + UnityEngine.SignInWithApple.UserInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.userId = LuaAPI.lua_tostring(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_email(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SignInWithApple.UserInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.email = LuaAPI.lua_tostring(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_displayName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SignInWithApple.UserInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.displayName = LuaAPI.lua_tostring(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_idToken(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SignInWithApple.UserInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.idToken = LuaAPI.lua_tostring(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_error(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SignInWithApple.UserInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.error = LuaAPI.lua_tostring(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_userDetectionStatus(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SignInWithApple.UserInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + UnityEngine.SignInWithApple.UserDetectionStatus gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.userDetectionStatus = gen_value; + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_SkinnedMeshRendererWrap.cs b/Assets/XLua/Gen/UnityEngine_SkinnedMeshRendererWrap.cs new file mode 100644 index 000000000..9c3e7c5a3 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_SkinnedMeshRendererWrap.cs @@ -0,0 +1,496 @@ +#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 UnityEngineSkinnedMeshRendererWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.SkinnedMeshRenderer); + Utils.BeginObjectRegister(type, L, translator, 0, 5, 8, 8); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetBlendShapeWeight", _m_GetBlendShapeWeight); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetBlendShapeWeight", _m_SetBlendShapeWeight); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "BakeMesh", _m_BakeMesh); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetVertexBuffer", _m_GetVertexBuffer); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPreviousVertexBuffer", _m_GetPreviousVertexBuffer); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "quality", _g_get_quality); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "updateWhenOffscreen", _g_get_updateWhenOffscreen); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "forceMatrixRecalculationPerRender", _g_get_forceMatrixRecalculationPerRender); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rootBone", _g_get_rootBone); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bones", _g_get_bones); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sharedMesh", _g_get_sharedMesh); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "skinnedMotionVectors", _g_get_skinnedMotionVectors); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "vertexBufferTarget", _g_get_vertexBufferTarget); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "quality", _s_set_quality); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "updateWhenOffscreen", _s_set_updateWhenOffscreen); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "forceMatrixRecalculationPerRender", _s_set_forceMatrixRecalculationPerRender); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "rootBone", _s_set_rootBone); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "bones", _s_set_bones); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sharedMesh", _s_set_sharedMesh); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "skinnedMotionVectors", _s_set_skinnedMotionVectors); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "vertexBufferTarget", _s_set_vertexBufferTarget); + + + 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 UnityEngine.SkinnedMeshRenderer(); + 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 UnityEngine.SkinnedMeshRenderer constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetBlendShapeWeight(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.SkinnedMeshRenderer gen_to_be_invoked = (UnityEngine.SkinnedMeshRenderer)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetBlendShapeWeight( _index ); + LuaAPI.lua_pushnumber(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_SetBlendShapeWeight(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.SkinnedMeshRenderer gen_to_be_invoked = (UnityEngine.SkinnedMeshRenderer)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + float _value = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetBlendShapeWeight( _index, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_BakeMesh(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.SkinnedMeshRenderer gen_to_be_invoked = (UnityEngine.SkinnedMeshRenderer)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + + gen_to_be_invoked.BakeMesh( _mesh ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Mesh _mesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + bool _useScale = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.BakeMesh( _mesh, _useScale ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.SkinnedMeshRenderer.BakeMesh!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetVertexBuffer(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.SkinnedMeshRenderer gen_to_be_invoked = (UnityEngine.SkinnedMeshRenderer)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetVertexBuffer( ); + 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_GetPreviousVertexBuffer(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.SkinnedMeshRenderer gen_to_be_invoked = (UnityEngine.SkinnedMeshRenderer)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetPreviousVertexBuffer( ); + 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_quality(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SkinnedMeshRenderer gen_to_be_invoked = (UnityEngine.SkinnedMeshRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.quality); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_updateWhenOffscreen(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SkinnedMeshRenderer gen_to_be_invoked = (UnityEngine.SkinnedMeshRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.updateWhenOffscreen); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_forceMatrixRecalculationPerRender(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SkinnedMeshRenderer gen_to_be_invoked = (UnityEngine.SkinnedMeshRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.forceMatrixRecalculationPerRender); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rootBone(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SkinnedMeshRenderer gen_to_be_invoked = (UnityEngine.SkinnedMeshRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.rootBone); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bones(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SkinnedMeshRenderer gen_to_be_invoked = (UnityEngine.SkinnedMeshRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.bones); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sharedMesh(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SkinnedMeshRenderer gen_to_be_invoked = (UnityEngine.SkinnedMeshRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.sharedMesh); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_skinnedMotionVectors(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SkinnedMeshRenderer gen_to_be_invoked = (UnityEngine.SkinnedMeshRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.skinnedMotionVectors); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_vertexBufferTarget(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SkinnedMeshRenderer gen_to_be_invoked = (UnityEngine.SkinnedMeshRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.vertexBufferTarget); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_quality(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SkinnedMeshRenderer gen_to_be_invoked = (UnityEngine.SkinnedMeshRenderer)translator.FastGetCSObj(L, 1); + UnityEngine.SkinQuality gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.quality = 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_updateWhenOffscreen(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SkinnedMeshRenderer gen_to_be_invoked = (UnityEngine.SkinnedMeshRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.updateWhenOffscreen = 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_forceMatrixRecalculationPerRender(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SkinnedMeshRenderer gen_to_be_invoked = (UnityEngine.SkinnedMeshRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.forceMatrixRecalculationPerRender = 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_rootBone(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SkinnedMeshRenderer gen_to_be_invoked = (UnityEngine.SkinnedMeshRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.rootBone = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_bones(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SkinnedMeshRenderer gen_to_be_invoked = (UnityEngine.SkinnedMeshRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.bones = (UnityEngine.Transform[])translator.GetObject(L, 2, typeof(UnityEngine.Transform[])); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_sharedMesh(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SkinnedMeshRenderer gen_to_be_invoked = (UnityEngine.SkinnedMeshRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.sharedMesh = (UnityEngine.Mesh)translator.GetObject(L, 2, typeof(UnityEngine.Mesh)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_skinnedMotionVectors(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SkinnedMeshRenderer gen_to_be_invoked = (UnityEngine.SkinnedMeshRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.skinnedMotionVectors = 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_vertexBufferTarget(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SkinnedMeshRenderer gen_to_be_invoked = (UnityEngine.SkinnedMeshRenderer)translator.FastGetCSObj(L, 1); + UnityEngine.GraphicsBuffer.Target gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.vertexBufferTarget = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_SphereColliderWrap.cs b/Assets/XLua/Gen/UnityEngine_SphereColliderWrap.cs new file mode 100644 index 000000000..d92f597d7 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_SphereColliderWrap.cs @@ -0,0 +1,147 @@ +#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 UnityEngineSphereColliderWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.SphereCollider); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 2); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "center", _g_get_center); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "radius", _g_get_radius); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "center", _s_set_center); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "radius", _s_set_radius); + + + 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 UnityEngine.SphereCollider(); + 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 UnityEngine.SphereCollider constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_center(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SphereCollider gen_to_be_invoked = (UnityEngine.SphereCollider)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.center); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_radius(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SphereCollider gen_to_be_invoked = (UnityEngine.SphereCollider)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.radius); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_center(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SphereCollider gen_to_be_invoked = (UnityEngine.SphereCollider)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.center = 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_radius(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SphereCollider gen_to_be_invoked = (UnityEngine.SphereCollider)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.radius = (float)LuaAPI.lua_tonumber(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_SpriteRendererWrap.cs b/Assets/XLua/Gen/UnityEngine_SpriteRendererWrap.cs new file mode 100644 index 000000000..aa03846a3 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_SpriteRendererWrap.cs @@ -0,0 +1,582 @@ +#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; +using DG.Tweening; + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class UnityEngineSpriteRendererWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.SpriteRenderer); + Utils.BeginObjectRegister(type, L, translator, 0, 6, 10, 10); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RegisterSpriteChangeCallback", _m_RegisterSpriteChangeCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnregisterSpriteChangeCallback", _m_UnregisterSpriteChangeCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOColor", _m_DOColor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOFade", _m_DOFade); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOGradientColor", _m_DOGradientColor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOBlendableColor", _m_DOBlendableColor); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sprite", _g_get_sprite); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "drawMode", _g_get_drawMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "size", _g_get_size); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "adaptiveModeThreshold", _g_get_adaptiveModeThreshold); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "tileMode", _g_get_tileMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "color", _g_get_color); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "maskInteraction", _g_get_maskInteraction); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "flipX", _g_get_flipX); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "flipY", _g_get_flipY); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "spriteSortPoint", _g_get_spriteSortPoint); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sprite", _s_set_sprite); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "drawMode", _s_set_drawMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "size", _s_set_size); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "adaptiveModeThreshold", _s_set_adaptiveModeThreshold); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "tileMode", _s_set_tileMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "color", _s_set_color); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "maskInteraction", _s_set_maskInteraction); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "flipX", _s_set_flipX); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "flipY", _s_set_flipY); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "spriteSortPoint", _s_set_spriteSortPoint); + + + 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 UnityEngine.SpriteRenderer(); + 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 UnityEngine.SpriteRenderer constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RegisterSpriteChangeCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.SpriteRenderer gen_to_be_invoked = (UnityEngine.SpriteRenderer)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Events.UnityAction _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.RegisterSpriteChangeCallback( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UnregisterSpriteChangeCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.SpriteRenderer gen_to_be_invoked = (UnityEngine.SpriteRenderer)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Events.UnityAction _callback = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.UnregisterSpriteChangeCallback( _callback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.SpriteRenderer gen_to_be_invoked = (UnityEngine.SpriteRenderer)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Color _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOColor( _endValue, _duration ); + 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_DOFade(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.SpriteRenderer gen_to_be_invoked = (UnityEngine.SpriteRenderer)translator.FastGetCSObj(L, 1); + + + + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOFade( _endValue, _duration ); + 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_DOGradientColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.SpriteRenderer gen_to_be_invoked = (UnityEngine.SpriteRenderer)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Gradient _gradient = (UnityEngine.Gradient)translator.GetObject(L, 2, typeof(UnityEngine.Gradient)); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOGradientColor( _gradient, _duration ); + 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_DOBlendableColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.SpriteRenderer gen_to_be_invoked = (UnityEngine.SpriteRenderer)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Color _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOBlendableColor( _endValue, _duration ); + 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_sprite(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SpriteRenderer gen_to_be_invoked = (UnityEngine.SpriteRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.sprite); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_drawMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SpriteRenderer gen_to_be_invoked = (UnityEngine.SpriteRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.drawMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_size(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SpriteRenderer gen_to_be_invoked = (UnityEngine.SpriteRenderer)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.size); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_adaptiveModeThreshold(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SpriteRenderer gen_to_be_invoked = (UnityEngine.SpriteRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.adaptiveModeThreshold); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_tileMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SpriteRenderer gen_to_be_invoked = (UnityEngine.SpriteRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.tileMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_color(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SpriteRenderer gen_to_be_invoked = (UnityEngine.SpriteRenderer)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineColor(L, gen_to_be_invoked.color); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maskInteraction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SpriteRenderer gen_to_be_invoked = (UnityEngine.SpriteRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.maskInteraction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_flipX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SpriteRenderer gen_to_be_invoked = (UnityEngine.SpriteRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.flipX); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_flipY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SpriteRenderer gen_to_be_invoked = (UnityEngine.SpriteRenderer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.flipY); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_spriteSortPoint(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SpriteRenderer gen_to_be_invoked = (UnityEngine.SpriteRenderer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.spriteSortPoint); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_sprite(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SpriteRenderer gen_to_be_invoked = (UnityEngine.SpriteRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.sprite = (UnityEngine.Sprite)translator.GetObject(L, 2, typeof(UnityEngine.Sprite)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_drawMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SpriteRenderer gen_to_be_invoked = (UnityEngine.SpriteRenderer)translator.FastGetCSObj(L, 1); + UnityEngine.SpriteDrawMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.drawMode = 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_size(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SpriteRenderer gen_to_be_invoked = (UnityEngine.SpriteRenderer)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.size = 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_adaptiveModeThreshold(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SpriteRenderer gen_to_be_invoked = (UnityEngine.SpriteRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.adaptiveModeThreshold = (float)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_tileMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SpriteRenderer gen_to_be_invoked = (UnityEngine.SpriteRenderer)translator.FastGetCSObj(L, 1); + UnityEngine.SpriteTileMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.tileMode = 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_color(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SpriteRenderer gen_to_be_invoked = (UnityEngine.SpriteRenderer)translator.FastGetCSObj(L, 1); + UnityEngine.Color gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.color = 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_maskInteraction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SpriteRenderer gen_to_be_invoked = (UnityEngine.SpriteRenderer)translator.FastGetCSObj(L, 1); + UnityEngine.SpriteMaskInteraction gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.maskInteraction = 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_flipX(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SpriteRenderer gen_to_be_invoked = (UnityEngine.SpriteRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.flipX = 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_flipY(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SpriteRenderer gen_to_be_invoked = (UnityEngine.SpriteRenderer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.flipY = 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_spriteSortPoint(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.SpriteRenderer gen_to_be_invoked = (UnityEngine.SpriteRenderer)translator.FastGetCSObj(L, 1); + UnityEngine.SpriteSortPoint gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.spriteSortPoint = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_SpriteWrap.cs b/Assets/XLua/Gen/UnityEngine_SpriteWrap.cs new file mode 100644 index 000000000..7aee52056 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_SpriteWrap.cs @@ -0,0 +1,570 @@ +#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 UnityEngineSpriteWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Sprite); + Utils.BeginObjectRegister(type, L, translator, 0, 5, 16, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPhysicsShapeCount", _m_GetPhysicsShapeCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPhysicsShapePointCount", _m_GetPhysicsShapePointCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPhysicsShape", _m_GetPhysicsShape); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OverridePhysicsShape", _m_OverridePhysicsShape); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OverrideGeometry", _m_OverrideGeometry); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bounds", _g_get_bounds); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rect", _g_get_rect); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "border", _g_get_border); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "texture", _g_get_texture); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "pixelsPerUnit", _g_get_pixelsPerUnit); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "spriteAtlasTextureScale", _g_get_spriteAtlasTextureScale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "associatedAlphaSplitTexture", _g_get_associatedAlphaSplitTexture); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "pivot", _g_get_pivot); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "packed", _g_get_packed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "packingMode", _g_get_packingMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "packingRotation", _g_get_packingRotation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "textureRect", _g_get_textureRect); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "textureRectOffset", _g_get_textureRectOffset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "vertices", _g_get_vertices); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "triangles", _g_get_triangles); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "uv", _g_get_uv); + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Create", _m_Create_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "UnityEngine.Sprite does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetPhysicsShapeCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Sprite gen_to_be_invoked = (UnityEngine.Sprite)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetPhysicsShapeCount( ); + 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_GetPhysicsShapePointCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Sprite gen_to_be_invoked = (UnityEngine.Sprite)translator.FastGetCSObj(L, 1); + + + + { + int _shapeIdx = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetPhysicsShapePointCount( _shapeIdx ); + 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_GetPhysicsShape(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Sprite gen_to_be_invoked = (UnityEngine.Sprite)translator.FastGetCSObj(L, 1); + + + + { + int _shapeIdx = LuaAPI.xlua_tointeger(L, 2); + System.Collections.Generic.List _physicsShape = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + var gen_ret = gen_to_be_invoked.GetPhysicsShape( _shapeIdx, _physicsShape ); + 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_OverridePhysicsShape(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Sprite gen_to_be_invoked = (UnityEngine.Sprite)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.IList _physicsShapes = (System.Collections.Generic.IList)translator.GetObject(L, 2, typeof(System.Collections.Generic.IList)); + + gen_to_be_invoked.OverridePhysicsShape( _physicsShapes ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OverrideGeometry(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Sprite gen_to_be_invoked = (UnityEngine.Sprite)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector2[] _vertices = (UnityEngine.Vector2[])translator.GetObject(L, 2, typeof(UnityEngine.Vector2[])); + ushort[] _triangles = (ushort[])translator.GetObject(L, 3, typeof(ushort[])); + + gen_to_be_invoked.OverrideGeometry( _vertices, _triangles ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Create_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Texture2D _texture = (UnityEngine.Texture2D)translator.GetObject(L, 1, typeof(UnityEngine.Texture2D)); + UnityEngine.Rect _rect;translator.Get(L, 2, out _rect); + UnityEngine.Vector2 _pivot;translator.Get(L, 3, out _pivot); + + var gen_ret = UnityEngine.Sprite.Create( _texture, _rect, _pivot ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Texture2D _texture = (UnityEngine.Texture2D)translator.GetObject(L, 1, typeof(UnityEngine.Texture2D)); + UnityEngine.Rect _rect;translator.Get(L, 2, out _rect); + UnityEngine.Vector2 _pivot;translator.Get(L, 3, out _pivot); + float _pixelsPerUnit = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = UnityEngine.Sprite.Create( _texture, _rect, _pivot, _pixelsPerUnit ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Texture2D _texture = (UnityEngine.Texture2D)translator.GetObject(L, 1, typeof(UnityEngine.Texture2D)); + UnityEngine.Rect _rect;translator.Get(L, 2, out _rect); + UnityEngine.Vector2 _pivot;translator.Get(L, 3, out _pivot); + float _pixelsPerUnit = (float)LuaAPI.lua_tonumber(L, 4); + uint _extrude = LuaAPI.xlua_touint(L, 5); + + var gen_ret = UnityEngine.Sprite.Create( _texture, _rect, _pivot, _pixelsPerUnit, _extrude ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)) + { + UnityEngine.Texture2D _texture = (UnityEngine.Texture2D)translator.GetObject(L, 1, typeof(UnityEngine.Texture2D)); + UnityEngine.Rect _rect;translator.Get(L, 2, out _rect); + UnityEngine.Vector2 _pivot;translator.Get(L, 3, out _pivot); + float _pixelsPerUnit = (float)LuaAPI.lua_tonumber(L, 4); + uint _extrude = LuaAPI.xlua_touint(L, 5); + UnityEngine.SpriteMeshType _meshType;translator.Get(L, 6, out _meshType); + + var gen_ret = UnityEngine.Sprite.Create( _texture, _rect, _pivot, _pixelsPerUnit, _extrude, _meshType ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 7&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& translator.Assignable(L, 7)) + { + UnityEngine.Texture2D _texture = (UnityEngine.Texture2D)translator.GetObject(L, 1, typeof(UnityEngine.Texture2D)); + UnityEngine.Rect _rect;translator.Get(L, 2, out _rect); + UnityEngine.Vector2 _pivot;translator.Get(L, 3, out _pivot); + float _pixelsPerUnit = (float)LuaAPI.lua_tonumber(L, 4); + uint _extrude = LuaAPI.xlua_touint(L, 5); + UnityEngine.SpriteMeshType _meshType;translator.Get(L, 6, out _meshType); + UnityEngine.Vector4 _border;translator.Get(L, 7, out _border); + + var gen_ret = UnityEngine.Sprite.Create( _texture, _rect, _pivot, _pixelsPerUnit, _extrude, _meshType, _border ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 8&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& translator.Assignable(L, 7)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 8)) + { + UnityEngine.Texture2D _texture = (UnityEngine.Texture2D)translator.GetObject(L, 1, typeof(UnityEngine.Texture2D)); + UnityEngine.Rect _rect;translator.Get(L, 2, out _rect); + UnityEngine.Vector2 _pivot;translator.Get(L, 3, out _pivot); + float _pixelsPerUnit = (float)LuaAPI.lua_tonumber(L, 4); + uint _extrude = LuaAPI.xlua_touint(L, 5); + UnityEngine.SpriteMeshType _meshType;translator.Get(L, 6, out _meshType); + UnityEngine.Vector4 _border;translator.Get(L, 7, out _border); + bool _generateFallbackPhysicsShape = LuaAPI.lua_toboolean(L, 8); + + var gen_ret = UnityEngine.Sprite.Create( _texture, _rect, _pivot, _pixelsPerUnit, _extrude, _meshType, _border, _generateFallbackPhysicsShape ); + 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 UnityEngine.Sprite.Create!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_bounds(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Sprite gen_to_be_invoked = (UnityEngine.Sprite)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineBounds(L, gen_to_be_invoked.bounds); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Sprite gen_to_be_invoked = (UnityEngine.Sprite)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.rect); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_border(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Sprite gen_to_be_invoked = (UnityEngine.Sprite)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector4(L, gen_to_be_invoked.border); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_texture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Sprite gen_to_be_invoked = (UnityEngine.Sprite)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.texture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_pixelsPerUnit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Sprite gen_to_be_invoked = (UnityEngine.Sprite)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.pixelsPerUnit); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_spriteAtlasTextureScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Sprite gen_to_be_invoked = (UnityEngine.Sprite)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.spriteAtlasTextureScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_associatedAlphaSplitTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Sprite gen_to_be_invoked = (UnityEngine.Sprite)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.associatedAlphaSplitTexture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_pivot(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Sprite gen_to_be_invoked = (UnityEngine.Sprite)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.pivot); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_packed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Sprite gen_to_be_invoked = (UnityEngine.Sprite)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.packed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_packingMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Sprite gen_to_be_invoked = (UnityEngine.Sprite)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.packingMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_packingRotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Sprite gen_to_be_invoked = (UnityEngine.Sprite)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.packingRotation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_textureRect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Sprite gen_to_be_invoked = (UnityEngine.Sprite)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.textureRect); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_textureRectOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Sprite gen_to_be_invoked = (UnityEngine.Sprite)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.textureRectOffset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_vertices(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Sprite gen_to_be_invoked = (UnityEngine.Sprite)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.vertices); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_triangles(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Sprite gen_to_be_invoked = (UnityEngine.Sprite)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.triangles); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_uv(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Sprite gen_to_be_invoked = (UnityEngine.Sprite)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.uv); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_SystemInfoWrap.cs b/Assets/XLua/Gen/UnityEngine_SystemInfoWrap.cs new file mode 100644 index 000000000..d9b5a2cd0 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_SystemInfoWrap.cs @@ -0,0 +1,1497 @@ +#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 UnityEngineSystemInfoWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.SystemInfo); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 11, 89, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SupportsRenderTextureFormat", _m_SupportsRenderTextureFormat_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SupportsBlendingOnRenderTextureFormat", _m_SupportsBlendingOnRenderTextureFormat_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SupportsRandomWriteOnRenderTextureFormat", _m_SupportsRandomWriteOnRenderTextureFormat_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SupportsTextureFormat", _m_SupportsTextureFormat_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SupportsVertexAttributeFormat", _m_SupportsVertexAttributeFormat_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IsFormatSupported", _m_IsFormatSupported_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetCompatibleFormat", _m_GetCompatibleFormat_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetGraphicsFormat", _m_GetGraphicsFormat_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetRenderTextureSupportedMSAASampleCount", _m_GetRenderTextureSupportedMSAASampleCount_xlua_st_); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "unsupportedIdentifier", UnityEngine.SystemInfo.unsupportedIdentifier); + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "batteryLevel", _g_get_batteryLevel); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "batteryStatus", _g_get_batteryStatus); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "operatingSystem", _g_get_operatingSystem); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "operatingSystemFamily", _g_get_operatingSystemFamily); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "processorType", _g_get_processorType); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "processorFrequency", _g_get_processorFrequency); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "processorCount", _g_get_processorCount); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "systemMemorySize", _g_get_systemMemorySize); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "deviceUniqueIdentifier", _g_get_deviceUniqueIdentifier); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "deviceName", _g_get_deviceName); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "deviceModel", _g_get_deviceModel); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsAccelerometer", _g_get_supportsAccelerometer); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsGyroscope", _g_get_supportsGyroscope); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsLocationService", _g_get_supportsLocationService); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsVibration", _g_get_supportsVibration); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsAudio", _g_get_supportsAudio); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "deviceType", _g_get_deviceType); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "graphicsMemorySize", _g_get_graphicsMemorySize); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "graphicsDeviceName", _g_get_graphicsDeviceName); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "graphicsDeviceVendor", _g_get_graphicsDeviceVendor); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "graphicsDeviceID", _g_get_graphicsDeviceID); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "graphicsDeviceVendorID", _g_get_graphicsDeviceVendorID); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "graphicsDeviceType", _g_get_graphicsDeviceType); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "graphicsUVStartsAtTop", _g_get_graphicsUVStartsAtTop); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "graphicsDeviceVersion", _g_get_graphicsDeviceVersion); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "graphicsShaderLevel", _g_get_graphicsShaderLevel); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "graphicsMultiThreaded", _g_get_graphicsMultiThreaded); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "renderingThreadingMode", _g_get_renderingThreadingMode); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "hasHiddenSurfaceRemovalOnGPU", _g_get_hasHiddenSurfaceRemovalOnGPU); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "hasDynamicUniformArrayIndexingInFragmentShaders", _g_get_hasDynamicUniformArrayIndexingInFragmentShaders); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsShadows", _g_get_supportsShadows); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsRawShadowDepthSampling", _g_get_supportsRawShadowDepthSampling); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsMotionVectors", _g_get_supportsMotionVectors); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supports3DTextures", _g_get_supports3DTextures); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsCompressed3DTextures", _g_get_supportsCompressed3DTextures); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supports2DArrayTextures", _g_get_supports2DArrayTextures); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supports3DRenderTextures", _g_get_supports3DRenderTextures); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsCubemapArrayTextures", _g_get_supportsCubemapArrayTextures); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsAnisotropicFilter", _g_get_supportsAnisotropicFilter); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "copyTextureSupport", _g_get_copyTextureSupport); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsComputeShaders", _g_get_supportsComputeShaders); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsGeometryShaders", _g_get_supportsGeometryShaders); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsTessellationShaders", _g_get_supportsTessellationShaders); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsRenderTargetArrayIndexFromVertexShader", _g_get_supportsRenderTargetArrayIndexFromVertexShader); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsInstancing", _g_get_supportsInstancing); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsHardwareQuadTopology", _g_get_supportsHardwareQuadTopology); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supports32bitsIndexBuffer", _g_get_supports32bitsIndexBuffer); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsSparseTextures", _g_get_supportsSparseTextures); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportedRenderTargetCount", _g_get_supportedRenderTargetCount); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsSeparatedRenderTargetsBlend", _g_get_supportsSeparatedRenderTargetsBlend); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportedRandomWriteTargetCount", _g_get_supportedRandomWriteTargetCount); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsMultisampledTextures", _g_get_supportsMultisampledTextures); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsMultisampled2DArrayTextures", _g_get_supportsMultisampled2DArrayTextures); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsMultisampleAutoResolve", _g_get_supportsMultisampleAutoResolve); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsTextureWrapMirrorOnce", _g_get_supportsTextureWrapMirrorOnce); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "usesReversedZBuffer", _g_get_usesReversedZBuffer); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "npotSupport", _g_get_npotSupport); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "maxTextureSize", _g_get_maxTextureSize); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "maxTexture3DSize", _g_get_maxTexture3DSize); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "maxTextureArraySlices", _g_get_maxTextureArraySlices); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "maxCubemapSize", _g_get_maxCubemapSize); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "maxAnisotropyLevel", _g_get_maxAnisotropyLevel); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "maxComputeBufferInputsVertex", _g_get_maxComputeBufferInputsVertex); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "maxComputeBufferInputsFragment", _g_get_maxComputeBufferInputsFragment); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "maxComputeBufferInputsGeometry", _g_get_maxComputeBufferInputsGeometry); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "maxComputeBufferInputsDomain", _g_get_maxComputeBufferInputsDomain); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "maxComputeBufferInputsHull", _g_get_maxComputeBufferInputsHull); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "maxComputeBufferInputsCompute", _g_get_maxComputeBufferInputsCompute); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "maxComputeWorkGroupSize", _g_get_maxComputeWorkGroupSize); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "maxComputeWorkGroupSizeX", _g_get_maxComputeWorkGroupSizeX); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "maxComputeWorkGroupSizeY", _g_get_maxComputeWorkGroupSizeY); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "maxComputeWorkGroupSizeZ", _g_get_maxComputeWorkGroupSizeZ); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "computeSubGroupSize", _g_get_computeSubGroupSize); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsAsyncCompute", _g_get_supportsAsyncCompute); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsGpuRecorder", _g_get_supportsGpuRecorder); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsGraphicsFence", _g_get_supportsGraphicsFence); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsAsyncGPUReadback", _g_get_supportsAsyncGPUReadback); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsRayTracing", _g_get_supportsRayTracing); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsSetConstantBuffer", _g_get_supportsSetConstantBuffer); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "constantBufferOffsetAlignment", _g_get_constantBufferOffsetAlignment); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "maxGraphicsBufferSize", _g_get_maxGraphicsBufferSize); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "hasMipMaxLevel", _g_get_hasMipMaxLevel); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsMipStreaming", _g_get_supportsMipStreaming); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "usesLoadStoreActions", _g_get_usesLoadStoreActions); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "hdrDisplaySupportFlags", _g_get_hdrDisplaySupportFlags); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsConservativeRaster", _g_get_supportsConservativeRaster); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsMultiview", _g_get_supportsMultiview); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsStoreAndResolveAction", _g_get_supportsStoreAndResolveAction); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "supportsMultisampleResolveDepth", _g_get_supportsMultisampleResolveDepth); + + + + 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 UnityEngine.SystemInfo(); + 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 UnityEngine.SystemInfo constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SupportsRenderTextureFormat_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.RenderTextureFormat _format;translator.Get(L, 1, out _format); + + var gen_ret = UnityEngine.SystemInfo.SupportsRenderTextureFormat( _format ); + 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_SupportsBlendingOnRenderTextureFormat_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.RenderTextureFormat _format;translator.Get(L, 1, out _format); + + var gen_ret = UnityEngine.SystemInfo.SupportsBlendingOnRenderTextureFormat( _format ); + 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_SupportsRandomWriteOnRenderTextureFormat_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.RenderTextureFormat _format;translator.Get(L, 1, out _format); + + var gen_ret = UnityEngine.SystemInfo.SupportsRandomWriteOnRenderTextureFormat( _format ); + 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_SupportsTextureFormat_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.TextureFormat _format;translator.Get(L, 1, out _format); + + var gen_ret = UnityEngine.SystemInfo.SupportsTextureFormat( _format ); + 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_SupportsVertexAttributeFormat_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Rendering.VertexAttributeFormat _format;translator.Get(L, 1, out _format); + int _dimension = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = UnityEngine.SystemInfo.SupportsVertexAttributeFormat( _format, _dimension ); + 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_IsFormatSupported_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Experimental.Rendering.GraphicsFormat _format;translator.Get(L, 1, out _format); + UnityEngine.Experimental.Rendering.FormatUsage _usage;translator.Get(L, 2, out _usage); + + var gen_ret = UnityEngine.SystemInfo.IsFormatSupported( _format, _usage ); + 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_GetCompatibleFormat_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Experimental.Rendering.GraphicsFormat _format;translator.Get(L, 1, out _format); + UnityEngine.Experimental.Rendering.FormatUsage _usage;translator.Get(L, 2, out _usage); + + var gen_ret = UnityEngine.SystemInfo.GetCompatibleFormat( _format, _usage ); + 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_GetGraphicsFormat_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Experimental.Rendering.DefaultFormat _format;translator.Get(L, 1, out _format); + + var gen_ret = UnityEngine.SystemInfo.GetGraphicsFormat( _format ); + 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_GetRenderTextureSupportedMSAASampleCount_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.RenderTextureDescriptor _desc;translator.Get(L, 1, out _desc); + + var gen_ret = UnityEngine.SystemInfo.GetRenderTextureSupportedMSAASampleCount( _desc ); + 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 _g_get_batteryLevel(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.SystemInfo.batteryLevel); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_batteryStatus(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineBatteryStatus(L, UnityEngine.SystemInfo.batteryStatus); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_operatingSystem(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, UnityEngine.SystemInfo.operatingSystem); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_operatingSystemFamily(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.SystemInfo.operatingSystemFamily); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_processorType(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, UnityEngine.SystemInfo.processorType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_processorFrequency(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SystemInfo.processorFrequency); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_processorCount(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SystemInfo.processorCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_systemMemorySize(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SystemInfo.systemMemorySize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_deviceUniqueIdentifier(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, UnityEngine.SystemInfo.deviceUniqueIdentifier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_deviceName(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, UnityEngine.SystemInfo.deviceName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_deviceModel(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, UnityEngine.SystemInfo.deviceModel); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsAccelerometer(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsAccelerometer); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsGyroscope(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsGyroscope); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsLocationService(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsLocationService); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsVibration(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsVibration); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsAudio(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsAudio); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_deviceType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.SystemInfo.deviceType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_graphicsMemorySize(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SystemInfo.graphicsMemorySize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_graphicsDeviceName(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, UnityEngine.SystemInfo.graphicsDeviceName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_graphicsDeviceVendor(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, UnityEngine.SystemInfo.graphicsDeviceVendor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_graphicsDeviceID(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SystemInfo.graphicsDeviceID); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_graphicsDeviceVendorID(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SystemInfo.graphicsDeviceVendorID); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_graphicsDeviceType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.SystemInfo.graphicsDeviceType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_graphicsUVStartsAtTop(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.graphicsUVStartsAtTop); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_graphicsDeviceVersion(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, UnityEngine.SystemInfo.graphicsDeviceVersion); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_graphicsShaderLevel(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SystemInfo.graphicsShaderLevel); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_graphicsMultiThreaded(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.graphicsMultiThreaded); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_renderingThreadingMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.SystemInfo.renderingThreadingMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_hasHiddenSurfaceRemovalOnGPU(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.hasHiddenSurfaceRemovalOnGPU); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_hasDynamicUniformArrayIndexingInFragmentShaders(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.hasDynamicUniformArrayIndexingInFragmentShaders); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsShadows(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsShadows); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsRawShadowDepthSampling(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsRawShadowDepthSampling); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsMotionVectors(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsMotionVectors); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supports3DTextures(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supports3DTextures); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsCompressed3DTextures(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsCompressed3DTextures); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supports2DArrayTextures(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supports2DArrayTextures); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supports3DRenderTextures(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supports3DRenderTextures); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsCubemapArrayTextures(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsCubemapArrayTextures); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsAnisotropicFilter(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsAnisotropicFilter); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_copyTextureSupport(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.SystemInfo.copyTextureSupport); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsComputeShaders(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsComputeShaders); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsGeometryShaders(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsGeometryShaders); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsTessellationShaders(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsTessellationShaders); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsRenderTargetArrayIndexFromVertexShader(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsRenderTargetArrayIndexFromVertexShader); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsInstancing(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsInstancing); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsHardwareQuadTopology(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsHardwareQuadTopology); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supports32bitsIndexBuffer(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supports32bitsIndexBuffer); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsSparseTextures(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsSparseTextures); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportedRenderTargetCount(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SystemInfo.supportedRenderTargetCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsSeparatedRenderTargetsBlend(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsSeparatedRenderTargetsBlend); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportedRandomWriteTargetCount(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SystemInfo.supportedRandomWriteTargetCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsMultisampledTextures(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SystemInfo.supportsMultisampledTextures); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsMultisampled2DArrayTextures(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsMultisampled2DArrayTextures); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsMultisampleAutoResolve(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsMultisampleAutoResolve); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsTextureWrapMirrorOnce(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SystemInfo.supportsTextureWrapMirrorOnce); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_usesReversedZBuffer(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.usesReversedZBuffer); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_npotSupport(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.SystemInfo.npotSupport); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxTextureSize(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SystemInfo.maxTextureSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxTexture3DSize(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SystemInfo.maxTexture3DSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxTextureArraySlices(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SystemInfo.maxTextureArraySlices); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxCubemapSize(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SystemInfo.maxCubemapSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxAnisotropyLevel(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SystemInfo.maxAnisotropyLevel); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxComputeBufferInputsVertex(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SystemInfo.maxComputeBufferInputsVertex); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxComputeBufferInputsFragment(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SystemInfo.maxComputeBufferInputsFragment); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxComputeBufferInputsGeometry(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SystemInfo.maxComputeBufferInputsGeometry); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxComputeBufferInputsDomain(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SystemInfo.maxComputeBufferInputsDomain); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxComputeBufferInputsHull(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SystemInfo.maxComputeBufferInputsHull); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxComputeBufferInputsCompute(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SystemInfo.maxComputeBufferInputsCompute); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxComputeWorkGroupSize(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SystemInfo.maxComputeWorkGroupSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxComputeWorkGroupSizeX(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SystemInfo.maxComputeWorkGroupSizeX); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxComputeWorkGroupSizeY(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SystemInfo.maxComputeWorkGroupSizeY); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxComputeWorkGroupSizeZ(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SystemInfo.maxComputeWorkGroupSizeZ); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_computeSubGroupSize(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SystemInfo.computeSubGroupSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsAsyncCompute(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsAsyncCompute); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsGpuRecorder(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsGpuRecorder); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsGraphicsFence(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsGraphicsFence); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsAsyncGPUReadback(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsAsyncGPUReadback); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsRayTracing(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsRayTracing); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsSetConstantBuffer(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsSetConstantBuffer); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_constantBufferOffsetAlignment(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.SystemInfo.constantBufferOffsetAlignment); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxGraphicsBufferSize(RealStatePtr L) + { + try { + + LuaAPI.lua_pushint64(L, UnityEngine.SystemInfo.maxGraphicsBufferSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_hasMipMaxLevel(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.hasMipMaxLevel); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsMipStreaming(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsMipStreaming); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_usesLoadStoreActions(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.usesLoadStoreActions); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_hdrDisplaySupportFlags(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.SystemInfo.hdrDisplaySupportFlags); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsConservativeRaster(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsConservativeRaster); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsMultiview(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsMultiview); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsStoreAndResolveAction(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsStoreAndResolveAction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportsMultisampleResolveDepth(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.SystemInfo.supportsMultisampleResolveDepth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_TextAssetWrap.cs b/Assets/XLua/Gen/UnityEngine_TextAssetWrap.cs new file mode 100644 index 000000000..d122bad25 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_TextAssetWrap.cs @@ -0,0 +1,167 @@ +#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 UnityEngineTextAssetWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.TextAsset); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 3, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "bytes", _g_get_bytes); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "text", _g_get_text); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "dataSize", _g_get_dataSize); + + + + 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 UnityEngine.TextAsset(); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _text = LuaAPI.lua_tostring(L, 2); + + var gen_ret = new UnityEngine.TextAsset(_text); + 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 UnityEngine.TextAsset constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.TextAsset gen_to_be_invoked = (UnityEngine.TextAsset)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_bytes(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextAsset gen_to_be_invoked = (UnityEngine.TextAsset)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.bytes); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_text(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextAsset gen_to_be_invoked = (UnityEngine.TextAsset)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.text); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_dataSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextAsset gen_to_be_invoked = (UnityEngine.TextAsset)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushint64(L, gen_to_be_invoked.dataSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_TextCore_FaceInfoWrap.cs b/Assets/XLua/Gen/UnityEngine_TextCore_FaceInfoWrap.cs new file mode 100644 index 000000000..dd8a3bd52 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_TextCore_FaceInfoWrap.cs @@ -0,0 +1,741 @@ +#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 UnityEngineTextCoreFaceInfoWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.TextCore.FaceInfo); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 19, 19); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Compare", _m_Compare); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "familyName", _g_get_familyName); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "styleName", _g_get_styleName); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "pointSize", _g_get_pointSize); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "scale", _g_get_scale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lineHeight", _g_get_lineHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ascentLine", _g_get_ascentLine); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "capLine", _g_get_capLine); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "meanLine", _g_get_meanLine); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "baseline", _g_get_baseline); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "descentLine", _g_get_descentLine); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "superscriptOffset", _g_get_superscriptOffset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "superscriptSize", _g_get_superscriptSize); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "subscriptOffset", _g_get_subscriptOffset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "subscriptSize", _g_get_subscriptSize); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "underlineOffset", _g_get_underlineOffset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "underlineThickness", _g_get_underlineThickness); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "strikethroughOffset", _g_get_strikethroughOffset); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "strikethroughThickness", _g_get_strikethroughThickness); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "tabWidth", _g_get_tabWidth); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "familyName", _s_set_familyName); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "styleName", _s_set_styleName); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "pointSize", _s_set_pointSize); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "scale", _s_set_scale); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "lineHeight", _s_set_lineHeight); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ascentLine", _s_set_ascentLine); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "capLine", _s_set_capLine); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "meanLine", _s_set_meanLine); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "baseline", _s_set_baseline); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "descentLine", _s_set_descentLine); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "superscriptOffset", _s_set_superscriptOffset); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "superscriptSize", _s_set_superscriptSize); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "subscriptOffset", _s_set_subscriptOffset); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "subscriptSize", _s_set_subscriptSize); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "underlineOffset", _s_set_underlineOffset); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "underlineThickness", _s_set_underlineThickness); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "strikethroughOffset", _s_set_strikethroughOffset); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "strikethroughThickness", _s_set_strikethroughThickness); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "tabWidth", _s_set_tabWidth); + + + 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) + { + translator.Push(L, default(UnityEngine.TextCore.FaceInfo)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.TextCore.FaceInfo constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Compare(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.TextCore.FaceInfo _other;translator.Get(L, 2, out _other); + + var gen_ret = gen_to_be_invoked.Compare( _other ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.Update(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_familyName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.familyName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_styleName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.styleName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_pointSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.pointSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_scale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.scale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lineHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.lineHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ascentLine(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.ascentLine); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_capLine(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.capLine); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_meanLine(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.meanLine); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_baseline(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.baseline); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_descentLine(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.descentLine); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_superscriptOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.superscriptOffset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_superscriptSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.superscriptSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_subscriptOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.subscriptOffset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_subscriptSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.subscriptSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_underlineOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.underlineOffset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_underlineThickness(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.underlineThickness); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_strikethroughOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.strikethroughOffset); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_strikethroughThickness(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.strikethroughThickness); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_tabWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.tabWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_familyName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.familyName = LuaAPI.lua_tostring(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_styleName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.styleName = LuaAPI.lua_tostring(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_pointSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.pointSize = LuaAPI.xlua_tointeger(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_scale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.scale = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_lineHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.lineHeight = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_ascentLine(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.ascentLine = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_capLine(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.capLine = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_meanLine(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.meanLine = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_baseline(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.baseline = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_descentLine(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.descentLine = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_superscriptOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.superscriptOffset = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_superscriptSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.superscriptSize = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_subscriptOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.subscriptOffset = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_subscriptSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.subscriptSize = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_underlineOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.underlineOffset = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_underlineThickness(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.underlineThickness = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_strikethroughOffset(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.strikethroughOffset = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_strikethroughThickness(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.strikethroughThickness = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_tabWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.TextCore.FaceInfo gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.tabWidth = (float)LuaAPI.lua_tonumber(L, 2); + + translator.Update(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_Texture2DWrap.cs b/Assets/XLua/Gen/UnityEngine_Texture2DWrap.cs new file mode 100644 index 000000000..01819d851 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_Texture2DWrap.cs @@ -0,0 +1,1380 @@ +#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 UnityEngineTexture2DWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Texture2D); + Utils.BeginObjectRegister(type, L, translator, 0, 18, 12, 3); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPixel", _m_SetPixel); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPixels", _m_SetPixels); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPixel", _m_GetPixel); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPixelBilinear", _m_GetPixelBilinear); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LoadRawTextureData", _m_LoadRawTextureData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Apply", _m_Apply); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Reinitialize", _m_Reinitialize); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ReadPixels", _m_ReadPixels); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPixels32", _m_SetPixels32); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPixels", _m_GetPixels); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Compress", _m_Compress); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearRequestedMipmapLevel", _m_ClearRequestedMipmapLevel); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsRequestedMipmapLevelLoaded", _m_IsRequestedMipmapLevelLoaded); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearMinimumMipmapLevel", _m_ClearMinimumMipmapLevel); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateExternalTexture", _m_UpdateExternalTexture); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetRawTextureData", _m_GetRawTextureData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPixels32", _m_GetPixels32); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PackTextures", _m_PackTextures); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "format", _g_get_format); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ignoreMipmapLimit", _g_get_ignoreMipmapLimit); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isReadable", _g_get_isReadable); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "vtOnly", _g_get_vtOnly); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "streamingMipmaps", _g_get_streamingMipmaps); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "streamingMipmapsPriority", _g_get_streamingMipmapsPriority); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "requestedMipmapLevel", _g_get_requestedMipmapLevel); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "minimumMipmapLevel", _g_get_minimumMipmapLevel); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "calculatedMipmapLevel", _g_get_calculatedMipmapLevel); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "desiredMipmapLevel", _g_get_desiredMipmapLevel); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "loadingMipmapLevel", _g_get_loadingMipmapLevel); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "loadedMipmapLevel", _g_get_loadedMipmapLevel); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ignoreMipmapLimit", _s_set_ignoreMipmapLimit); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "requestedMipmapLevel", _s_set_requestedMipmapLevel); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "minimumMipmapLevel", _s_set_minimumMipmapLevel); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 3, 6, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "CreateExternalTexture", _m_CreateExternalTexture_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GenerateAtlas", _m_GenerateAtlas_xlua_st_); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "whiteTexture", _g_get_whiteTexture); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "blackTexture", _g_get_blackTexture); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "redTexture", _g_get_redTexture); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "grayTexture", _g_get_grayTexture); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "linearGrayTexture", _g_get_linearGrayTexture); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "normalTexture", _g_get_normalTexture); + + + + 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) == 5 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && translator.Assignable(L, 4) && translator.Assignable(L, 5)) + { + int _width = LuaAPI.xlua_tointeger(L, 2); + int _height = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.Experimental.Rendering.DefaultFormat _format;translator.Get(L, 4, out _format); + UnityEngine.Experimental.Rendering.TextureCreationFlags _flags;translator.Get(L, 5, out _flags); + + var gen_ret = new UnityEngine.Texture2D(_width, _height, _format, _flags); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 5 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && translator.Assignable(L, 4) && translator.Assignable(L, 5)) + { + int _width = LuaAPI.xlua_tointeger(L, 2); + int _height = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.Experimental.Rendering.GraphicsFormat _format;translator.Get(L, 4, out _format); + UnityEngine.Experimental.Rendering.TextureCreationFlags _flags;translator.Get(L, 5, out _flags); + + var gen_ret = new UnityEngine.Texture2D(_width, _height, _format, _flags); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 6 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && translator.Assignable(L, 4) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5) && translator.Assignable(L, 6)) + { + int _width = LuaAPI.xlua_tointeger(L, 2); + int _height = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.Experimental.Rendering.GraphicsFormat _format;translator.Get(L, 4, out _format); + int _mipCount = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Experimental.Rendering.TextureCreationFlags _flags;translator.Get(L, 6, out _flags); + + var gen_ret = new UnityEngine.Texture2D(_width, _height, _format, _mipCount, _flags); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 6 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && translator.Assignable(L, 4) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5) && LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)) + { + int _width = LuaAPI.xlua_tointeger(L, 2); + int _height = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.TextureFormat _textureFormat;translator.Get(L, 4, out _textureFormat); + int _mipCount = LuaAPI.xlua_tointeger(L, 5); + bool _linear = LuaAPI.lua_toboolean(L, 6); + + var gen_ret = new UnityEngine.Texture2D(_width, _height, _textureFormat, _mipCount, _linear); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 6 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && translator.Assignable(L, 4) && LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5) && LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)) + { + int _width = LuaAPI.xlua_tointeger(L, 2); + int _height = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.TextureFormat _textureFormat;translator.Get(L, 4, out _textureFormat); + bool _mipChain = LuaAPI.lua_toboolean(L, 5); + bool _linear = LuaAPI.lua_toboolean(L, 6); + + var gen_ret = new UnityEngine.Texture2D(_width, _height, _textureFormat, _mipChain, _linear); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 5 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && translator.Assignable(L, 4) && LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)) + { + int _width = LuaAPI.xlua_tointeger(L, 2); + int _height = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.TextureFormat _textureFormat;translator.Get(L, 4, out _textureFormat); + bool _mipChain = LuaAPI.lua_toboolean(L, 5); + + var gen_ret = new UnityEngine.Texture2D(_width, _height, _textureFormat, _mipChain); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 3 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _width = LuaAPI.xlua_tointeger(L, 2); + int _height = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = new UnityEngine.Texture2D(_width, _height); + 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 UnityEngine.Texture2D constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CreateExternalTexture_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + int _width = LuaAPI.xlua_tointeger(L, 1); + int _height = LuaAPI.xlua_tointeger(L, 2); + UnityEngine.TextureFormat _format;translator.Get(L, 3, out _format); + bool _mipChain = LuaAPI.lua_toboolean(L, 4); + bool _linear = LuaAPI.lua_toboolean(L, 5); + System.IntPtr _nativeTex = LuaAPI.lua_touserdata(L, 6); + + var gen_ret = UnityEngine.Texture2D.CreateExternalTexture( _width, _height, _format, _mipChain, _linear, _nativeTex ); + 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_SetPixel(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + int _x = LuaAPI.xlua_tointeger(L, 2); + int _y = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.Color _color;translator.Get(L, 4, out _color); + + gen_to_be_invoked.SetPixel( _x, _y, _color ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int _x = LuaAPI.xlua_tointeger(L, 2); + int _y = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.Color _color;translator.Get(L, 4, out _color); + int _mipLevel = LuaAPI.xlua_tointeger(L, 5); + + gen_to_be_invoked.SetPixel( _x, _y, _color, _mipLevel ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Texture2D.SetPixel!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetPixels(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Color[] _colors = (UnityEngine.Color[])translator.GetObject(L, 2, typeof(UnityEngine.Color[])); + + gen_to_be_invoked.SetPixels( _colors ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Color[] _colors = (UnityEngine.Color[])translator.GetObject(L, 2, typeof(UnityEngine.Color[])); + int _miplevel = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetPixels( _colors, _miplevel ); + + + + return 0; + } + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)) + { + int _x = LuaAPI.xlua_tointeger(L, 2); + int _y = LuaAPI.xlua_tointeger(L, 3); + int _blockWidth = LuaAPI.xlua_tointeger(L, 4); + int _blockHeight = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Color[] _colors = (UnityEngine.Color[])translator.GetObject(L, 6, typeof(UnityEngine.Color[])); + + gen_to_be_invoked.SetPixels( _x, _y, _blockWidth, _blockHeight, _colors ); + + + + return 0; + } + if(gen_param_count == 7&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)) + { + int _x = LuaAPI.xlua_tointeger(L, 2); + int _y = LuaAPI.xlua_tointeger(L, 3); + int _blockWidth = LuaAPI.xlua_tointeger(L, 4); + int _blockHeight = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Color[] _colors = (UnityEngine.Color[])translator.GetObject(L, 6, typeof(UnityEngine.Color[])); + int _miplevel = LuaAPI.xlua_tointeger(L, 7); + + gen_to_be_invoked.SetPixels( _x, _y, _blockWidth, _blockHeight, _colors, _miplevel ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Texture2D.SetPixels!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetPixel(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _x = LuaAPI.xlua_tointeger(L, 2); + int _y = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.GetPixel( _x, _y ); + translator.PushUnityEngineColor(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + int _x = LuaAPI.xlua_tointeger(L, 2); + int _y = LuaAPI.xlua_tointeger(L, 3); + int _mipLevel = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.GetPixel( _x, _y, _mipLevel ); + translator.PushUnityEngineColor(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 UnityEngine.Texture2D.GetPixel!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetPixelBilinear(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _u = (float)LuaAPI.lua_tonumber(L, 2); + float _v = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.GetPixelBilinear( _u, _v ); + translator.PushUnityEngineColor(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _u = (float)LuaAPI.lua_tonumber(L, 2); + float _v = (float)LuaAPI.lua_tonumber(L, 3); + int _mipLevel = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.GetPixelBilinear( _u, _v, _mipLevel ); + translator.PushUnityEngineColor(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 UnityEngine.Texture2D.GetPixelBilinear!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LoadRawTextureData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TLIGHTUSERDATA == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + System.IntPtr _data = LuaAPI.lua_touserdata(L, 2); + int _size = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.LoadRawTextureData( _data, _size ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + byte[] _data = LuaAPI.lua_tobytes(L, 2); + + gen_to_be_invoked.LoadRawTextureData( _data ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Texture2D.LoadRawTextureData!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Apply(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.Apply( ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _updateMipmaps = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.Apply( _updateMipmaps ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + bool _updateMipmaps = LuaAPI.lua_toboolean(L, 2); + bool _makeNoLongerReadable = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.Apply( _updateMipmaps, _makeNoLongerReadable ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Texture2D.Apply!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Reinitialize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + int _width = LuaAPI.xlua_tointeger(L, 2); + int _height = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.Reinitialize( _width, _height ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)) + { + int _width = LuaAPI.xlua_tointeger(L, 2); + int _height = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.TextureFormat _format;translator.Get(L, 4, out _format); + bool _hasMipMap = LuaAPI.lua_toboolean(L, 5); + + var gen_ret = gen_to_be_invoked.Reinitialize( _width, _height, _format, _hasMipMap ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)) + { + int _width = LuaAPI.xlua_tointeger(L, 2); + int _height = LuaAPI.xlua_tointeger(L, 3); + UnityEngine.Experimental.Rendering.GraphicsFormat _format;translator.Get(L, 4, out _format); + bool _hasMipMap = LuaAPI.lua_toboolean(L, 5); + + var gen_ret = gen_to_be_invoked.Reinitialize( _width, _height, _format, _hasMipMap ); + LuaAPI.lua_pushboolean(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 UnityEngine.Texture2D.Reinitialize!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ReadPixels(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Rect _source;translator.Get(L, 2, out _source); + int _destX = LuaAPI.xlua_tointeger(L, 3); + int _destY = LuaAPI.xlua_tointeger(L, 4); + + gen_to_be_invoked.ReadPixels( _source, _destX, _destY ); + + + + return 0; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Rect _source;translator.Get(L, 2, out _source); + int _destX = LuaAPI.xlua_tointeger(L, 3); + int _destY = LuaAPI.xlua_tointeger(L, 4); + bool _recalculateMipMaps = LuaAPI.lua_toboolean(L, 5); + + gen_to_be_invoked.ReadPixels( _source, _destX, _destY, _recalculateMipMaps ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Texture2D.ReadPixels!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GenerateAtlas_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector2[] _sizes = (UnityEngine.Vector2[])translator.GetObject(L, 1, typeof(UnityEngine.Vector2[])); + int _padding = LuaAPI.xlua_tointeger(L, 2); + int _atlasSize = LuaAPI.xlua_tointeger(L, 3); + System.Collections.Generic.List _results = (System.Collections.Generic.List)translator.GetObject(L, 4, typeof(System.Collections.Generic.List)); + + var gen_ret = UnityEngine.Texture2D.GenerateAtlas( _sizes, _padding, _atlasSize, _results ); + 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_SetPixels32(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Color32[] _colors = (UnityEngine.Color32[])translator.GetObject(L, 2, typeof(UnityEngine.Color32[])); + + gen_to_be_invoked.SetPixels32( _colors ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Color32[] _colors = (UnityEngine.Color32[])translator.GetObject(L, 2, typeof(UnityEngine.Color32[])); + int _miplevel = LuaAPI.xlua_tointeger(L, 3); + + gen_to_be_invoked.SetPixels32( _colors, _miplevel ); + + + + return 0; + } + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)) + { + int _x = LuaAPI.xlua_tointeger(L, 2); + int _y = LuaAPI.xlua_tointeger(L, 3); + int _blockWidth = LuaAPI.xlua_tointeger(L, 4); + int _blockHeight = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Color32[] _colors = (UnityEngine.Color32[])translator.GetObject(L, 6, typeof(UnityEngine.Color32[])); + + gen_to_be_invoked.SetPixels32( _x, _y, _blockWidth, _blockHeight, _colors ); + + + + return 0; + } + if(gen_param_count == 7&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 7)) + { + int _x = LuaAPI.xlua_tointeger(L, 2); + int _y = LuaAPI.xlua_tointeger(L, 3); + int _blockWidth = LuaAPI.xlua_tointeger(L, 4); + int _blockHeight = LuaAPI.xlua_tointeger(L, 5); + UnityEngine.Color32[] _colors = (UnityEngine.Color32[])translator.GetObject(L, 6, typeof(UnityEngine.Color32[])); + int _miplevel = LuaAPI.xlua_tointeger(L, 7); + + gen_to_be_invoked.SetPixels32( _x, _y, _blockWidth, _blockHeight, _colors, _miplevel ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Texture2D.SetPixels32!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetPixels(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.GetPixels( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _miplevel = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetPixels( _miplevel ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + int _x = LuaAPI.xlua_tointeger(L, 2); + int _y = LuaAPI.xlua_tointeger(L, 3); + int _blockWidth = LuaAPI.xlua_tointeger(L, 4); + int _blockHeight = LuaAPI.xlua_tointeger(L, 5); + + var gen_ret = gen_to_be_invoked.GetPixels( _x, _y, _blockWidth, _blockHeight ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + int _x = LuaAPI.xlua_tointeger(L, 2); + int _y = LuaAPI.xlua_tointeger(L, 3); + int _blockWidth = LuaAPI.xlua_tointeger(L, 4); + int _blockHeight = LuaAPI.xlua_tointeger(L, 5); + int _miplevel = LuaAPI.xlua_tointeger(L, 6); + + var gen_ret = gen_to_be_invoked.GetPixels( _x, _y, _blockWidth, _blockHeight, _miplevel ); + 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 UnityEngine.Texture2D.GetPixels!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Compress(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + + + + { + bool _highQuality = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.Compress( _highQuality ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearRequestedMipmapLevel(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearRequestedMipmapLevel( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsRequestedMipmapLevelLoaded(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsRequestedMipmapLevelLoaded( ); + 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_ClearMinimumMipmapLevel(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearMinimumMipmapLevel( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UpdateExternalTexture(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + + + + { + System.IntPtr _nativeTex = LuaAPI.lua_touserdata(L, 2); + + gen_to_be_invoked.UpdateExternalTexture( _nativeTex ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetRawTextureData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetRawTextureData( ); + 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 _m_GetPixels32(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.GetPixels32( ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _miplevel = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetPixels32( _miplevel ); + 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 UnityEngine.Texture2D.GetPixels32!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_PackTextures(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Texture2D[] _textures = (UnityEngine.Texture2D[])translator.GetObject(L, 2, typeof(UnityEngine.Texture2D[])); + int _padding = LuaAPI.xlua_tointeger(L, 3); + + var gen_ret = gen_to_be_invoked.PackTextures( _textures, _padding ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Texture2D[] _textures = (UnityEngine.Texture2D[])translator.GetObject(L, 2, typeof(UnityEngine.Texture2D[])); + int _padding = LuaAPI.xlua_tointeger(L, 3); + int _maximumAtlasSize = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.PackTextures( _textures, _padding, _maximumAtlasSize ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Texture2D[] _textures = (UnityEngine.Texture2D[])translator.GetObject(L, 2, typeof(UnityEngine.Texture2D[])); + int _padding = LuaAPI.xlua_tointeger(L, 3); + int _maximumAtlasSize = LuaAPI.xlua_tointeger(L, 4); + bool _makeNoLongerReadable = LuaAPI.lua_toboolean(L, 5); + + var gen_ret = gen_to_be_invoked.PackTextures( _textures, _padding, _maximumAtlasSize, _makeNoLongerReadable ); + 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 UnityEngine.Texture2D.PackTextures!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_format(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.format); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ignoreMipmapLimit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.ignoreMipmapLimit); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_whiteTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Texture2D.whiteTexture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_blackTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Texture2D.blackTexture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_redTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Texture2D.redTexture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_grayTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Texture2D.grayTexture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_linearGrayTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Texture2D.linearGrayTexture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_normalTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Texture2D.normalTexture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isReadable(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isReadable); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_vtOnly(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.vtOnly); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_streamingMipmaps(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.streamingMipmaps); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_streamingMipmapsPriority(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.streamingMipmapsPriority); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_requestedMipmapLevel(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.requestedMipmapLevel); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_minimumMipmapLevel(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.minimumMipmapLevel); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_calculatedMipmapLevel(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.calculatedMipmapLevel); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_desiredMipmapLevel(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.desiredMipmapLevel); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_loadingMipmapLevel(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.loadingMipmapLevel); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_loadedMipmapLevel(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.loadedMipmapLevel); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_ignoreMipmapLimit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ignoreMipmapLimit = 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_requestedMipmapLevel(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.requestedMipmapLevel = 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_minimumMipmapLevel(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture2D gen_to_be_invoked = (UnityEngine.Texture2D)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.minimumMipmapLevel = 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/UnityEngine_TextureWrap.cs b/Assets/XLua/Gen/UnityEngine_TextureWrap.cs new file mode 100644 index 000000000..b155313e6 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_TextureWrap.cs @@ -0,0 +1,860 @@ +#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 UnityEngineTextureWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Texture); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 16, 10); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetNativeTexturePtr", _m_GetNativeTexturePtr); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IncrementUpdateCount", _m_IncrementUpdateCount); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mipmapCount", _g_get_mipmapCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "graphicsFormat", _g_get_graphicsFormat); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "width", _g_get_width); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "height", _g_get_height); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "dimension", _g_get_dimension); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isReadable", _g_get_isReadable); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "wrapMode", _g_get_wrapMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "wrapModeU", _g_get_wrapModeU); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "wrapModeV", _g_get_wrapModeV); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "wrapModeW", _g_get_wrapModeW); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "filterMode", _g_get_filterMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "anisoLevel", _g_get_anisoLevel); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mipMapBias", _g_get_mipMapBias); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "texelSize", _g_get_texelSize); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "updateCount", _g_get_updateCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isDataSRGB", _g_get_isDataSRGB); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "width", _s_set_width); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "height", _s_set_height); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "dimension", _s_set_dimension); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "wrapMode", _s_set_wrapMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "wrapModeU", _s_set_wrapModeU); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "wrapModeV", _s_set_wrapModeV); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "wrapModeW", _s_set_wrapModeW); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "filterMode", _s_set_filterMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "anisoLevel", _s_set_anisoLevel); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "mipMapBias", _s_set_mipMapBias); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 4, 16, 5); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetGlobalAnisotropicFilteringLimits", _m_SetGlobalAnisotropicFilteringLimits_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetStreamingTextureMaterialDebugProperties", _m_SetStreamingTextureMaterialDebugProperties_xlua_st_); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GenerateAllMips", UnityEngine.Texture.GenerateAllMips); + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "masterTextureLimit", _g_get_masterTextureLimit); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "anisotropicFiltering", _g_get_anisotropicFiltering); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "totalTextureMemory", _g_get_totalTextureMemory); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "desiredTextureMemory", _g_get_desiredTextureMemory); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "targetTextureMemory", _g_get_targetTextureMemory); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "currentTextureMemory", _g_get_currentTextureMemory); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "nonStreamingTextureMemory", _g_get_nonStreamingTextureMemory); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "streamingMipmapUploadCount", _g_get_streamingMipmapUploadCount); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "streamingRendererCount", _g_get_streamingRendererCount); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "streamingTextureCount", _g_get_streamingTextureCount); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "nonStreamingTextureCount", _g_get_nonStreamingTextureCount); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "streamingTexturePendingLoadCount", _g_get_streamingTexturePendingLoadCount); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "streamingTextureLoadingCount", _g_get_streamingTextureLoadingCount); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "streamingTextureForceLoadAll", _g_get_streamingTextureForceLoadAll); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "streamingTextureDiscardUnusedMips", _g_get_streamingTextureDiscardUnusedMips); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "allowThreadedTextureCreation", _g_get_allowThreadedTextureCreation); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "masterTextureLimit", _s_set_masterTextureLimit); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "anisotropicFiltering", _s_set_anisotropicFiltering); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "streamingTextureForceLoadAll", _s_set_streamingTextureForceLoadAll); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "streamingTextureDiscardUnusedMips", _s_set_streamingTextureDiscardUnusedMips); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "allowThreadedTextureCreation", _s_set_allowThreadedTextureCreation); + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "UnityEngine.Texture does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetGlobalAnisotropicFilteringLimits_xlua_st_(RealStatePtr L) + { + try { + + + + + { + int _forcedMin = LuaAPI.xlua_tointeger(L, 1); + int _globalMax = LuaAPI.xlua_tointeger(L, 2); + + UnityEngine.Texture.SetGlobalAnisotropicFilteringLimits( _forcedMin, _globalMax ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetNativeTexturePtr(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Texture gen_to_be_invoked = (UnityEngine.Texture)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetNativeTexturePtr( ); + LuaAPI.lua_pushlightuserdata(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_IncrementUpdateCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Texture gen_to_be_invoked = (UnityEngine.Texture)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.IncrementUpdateCount( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetStreamingTextureMaterialDebugProperties_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + UnityEngine.Texture.SetStreamingTextureMaterialDebugProperties( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_masterTextureLimit(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.Texture.masterTextureLimit); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mipmapCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture gen_to_be_invoked = (UnityEngine.Texture)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.mipmapCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_anisotropicFiltering(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.Texture.anisotropicFiltering); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_graphicsFormat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture gen_to_be_invoked = (UnityEngine.Texture)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.graphicsFormat); + } 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); + + UnityEngine.Texture gen_to_be_invoked = (UnityEngine.Texture)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); + + UnityEngine.Texture gen_to_be_invoked = (UnityEngine.Texture)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 _g_get_dimension(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture gen_to_be_invoked = (UnityEngine.Texture)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.dimension); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isReadable(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture gen_to_be_invoked = (UnityEngine.Texture)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isReadable); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_wrapMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture gen_to_be_invoked = (UnityEngine.Texture)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.wrapMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_wrapModeU(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture gen_to_be_invoked = (UnityEngine.Texture)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.wrapModeU); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_wrapModeV(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture gen_to_be_invoked = (UnityEngine.Texture)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.wrapModeV); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_wrapModeW(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture gen_to_be_invoked = (UnityEngine.Texture)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.wrapModeW); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_filterMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture gen_to_be_invoked = (UnityEngine.Texture)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.filterMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_anisoLevel(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture gen_to_be_invoked = (UnityEngine.Texture)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.anisoLevel); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mipMapBias(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture gen_to_be_invoked = (UnityEngine.Texture)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.mipMapBias); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_texelSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture gen_to_be_invoked = (UnityEngine.Texture)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.texelSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_updateCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture gen_to_be_invoked = (UnityEngine.Texture)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushuint(L, gen_to_be_invoked.updateCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isDataSRGB(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture gen_to_be_invoked = (UnityEngine.Texture)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isDataSRGB); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_totalTextureMemory(RealStatePtr L) + { + try { + + LuaAPI.lua_pushuint64(L, UnityEngine.Texture.totalTextureMemory); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_desiredTextureMemory(RealStatePtr L) + { + try { + + LuaAPI.lua_pushuint64(L, UnityEngine.Texture.desiredTextureMemory); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_targetTextureMemory(RealStatePtr L) + { + try { + + LuaAPI.lua_pushuint64(L, UnityEngine.Texture.targetTextureMemory); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_currentTextureMemory(RealStatePtr L) + { + try { + + LuaAPI.lua_pushuint64(L, UnityEngine.Texture.currentTextureMemory); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_nonStreamingTextureMemory(RealStatePtr L) + { + try { + + LuaAPI.lua_pushuint64(L, UnityEngine.Texture.nonStreamingTextureMemory); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_streamingMipmapUploadCount(RealStatePtr L) + { + try { + + LuaAPI.lua_pushuint64(L, UnityEngine.Texture.streamingMipmapUploadCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_streamingRendererCount(RealStatePtr L) + { + try { + + LuaAPI.lua_pushuint64(L, UnityEngine.Texture.streamingRendererCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_streamingTextureCount(RealStatePtr L) + { + try { + + LuaAPI.lua_pushuint64(L, UnityEngine.Texture.streamingTextureCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_nonStreamingTextureCount(RealStatePtr L) + { + try { + + LuaAPI.lua_pushuint64(L, UnityEngine.Texture.nonStreamingTextureCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_streamingTexturePendingLoadCount(RealStatePtr L) + { + try { + + LuaAPI.lua_pushuint64(L, UnityEngine.Texture.streamingTexturePendingLoadCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_streamingTextureLoadingCount(RealStatePtr L) + { + try { + + LuaAPI.lua_pushuint64(L, UnityEngine.Texture.streamingTextureLoadingCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_streamingTextureForceLoadAll(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Texture.streamingTextureForceLoadAll); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_streamingTextureDiscardUnusedMips(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Texture.streamingTextureDiscardUnusedMips); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_allowThreadedTextureCreation(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Texture.allowThreadedTextureCreation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_masterTextureLimit(RealStatePtr L) + { + try { + + UnityEngine.Texture.masterTextureLimit = LuaAPI.xlua_tointeger(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_anisotropicFiltering(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + UnityEngine.AnisotropicFiltering gen_value;translator.Get(L, 1, out gen_value); + UnityEngine.Texture.anisotropicFiltering = 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_width(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture gen_to_be_invoked = (UnityEngine.Texture)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); + + UnityEngine.Texture gen_to_be_invoked = (UnityEngine.Texture)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; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_dimension(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture gen_to_be_invoked = (UnityEngine.Texture)translator.FastGetCSObj(L, 1); + UnityEngine.Rendering.TextureDimension gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.dimension = 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_wrapMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture gen_to_be_invoked = (UnityEngine.Texture)translator.FastGetCSObj(L, 1); + UnityEngine.TextureWrapMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.wrapMode = 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_wrapModeU(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture gen_to_be_invoked = (UnityEngine.Texture)translator.FastGetCSObj(L, 1); + UnityEngine.TextureWrapMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.wrapModeU = 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_wrapModeV(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture gen_to_be_invoked = (UnityEngine.Texture)translator.FastGetCSObj(L, 1); + UnityEngine.TextureWrapMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.wrapModeV = 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_wrapModeW(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture gen_to_be_invoked = (UnityEngine.Texture)translator.FastGetCSObj(L, 1); + UnityEngine.TextureWrapMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.wrapModeW = 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_filterMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture gen_to_be_invoked = (UnityEngine.Texture)translator.FastGetCSObj(L, 1); + UnityEngine.FilterMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.filterMode = 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_anisoLevel(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture gen_to_be_invoked = (UnityEngine.Texture)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.anisoLevel = 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_mipMapBias(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Texture gen_to_be_invoked = (UnityEngine.Texture)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.mipMapBias = (float)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_streamingTextureForceLoadAll(RealStatePtr L) + { + try { + + UnityEngine.Texture.streamingTextureForceLoadAll = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_streamingTextureDiscardUnusedMips(RealStatePtr L) + { + try { + + UnityEngine.Texture.streamingTextureDiscardUnusedMips = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_allowThreadedTextureCreation(RealStatePtr L) + { + try { + + UnityEngine.Texture.allowThreadedTextureCreation = LuaAPI.lua_toboolean(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_TimeWrap.cs b/Assets/XLua/Gen/UnityEngine_TimeWrap.cs new file mode 100644 index 000000000..7fabfc24d --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_TimeWrap.cs @@ -0,0 +1,493 @@ +#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 UnityEngineTimeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Time); + 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, 25, 6); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "time", _g_get_time); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "timeAsDouble", _g_get_timeAsDouble); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "timeSinceLevelLoad", _g_get_timeSinceLevelLoad); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "timeSinceLevelLoadAsDouble", _g_get_timeSinceLevelLoadAsDouble); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "deltaTime", _g_get_deltaTime); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "fixedTime", _g_get_fixedTime); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "fixedTimeAsDouble", _g_get_fixedTimeAsDouble); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "unscaledTime", _g_get_unscaledTime); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "unscaledTimeAsDouble", _g_get_unscaledTimeAsDouble); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "fixedUnscaledTime", _g_get_fixedUnscaledTime); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "fixedUnscaledTimeAsDouble", _g_get_fixedUnscaledTimeAsDouble); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "unscaledDeltaTime", _g_get_unscaledDeltaTime); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "fixedUnscaledDeltaTime", _g_get_fixedUnscaledDeltaTime); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "fixedDeltaTime", _g_get_fixedDeltaTime); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "maximumDeltaTime", _g_get_maximumDeltaTime); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "smoothDeltaTime", _g_get_smoothDeltaTime); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "maximumParticleDeltaTime", _g_get_maximumParticleDeltaTime); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "timeScale", _g_get_timeScale); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "frameCount", _g_get_frameCount); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "renderedFrameCount", _g_get_renderedFrameCount); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "realtimeSinceStartup", _g_get_realtimeSinceStartup); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "realtimeSinceStartupAsDouble", _g_get_realtimeSinceStartupAsDouble); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "captureDeltaTime", _g_get_captureDeltaTime); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "captureFramerate", _g_get_captureFramerate); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "inFixedTimeStep", _g_get_inFixedTimeStep); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "fixedDeltaTime", _s_set_fixedDeltaTime); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "maximumDeltaTime", _s_set_maximumDeltaTime); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "maximumParticleDeltaTime", _s_set_maximumParticleDeltaTime); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "timeScale", _s_set_timeScale); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "captureDeltaTime", _s_set_captureDeltaTime); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "captureFramerate", _s_set_captureFramerate); + + + 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 UnityEngine.Time(); + 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 UnityEngine.Time constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_time(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Time.time); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_timeAsDouble(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Time.timeAsDouble); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_timeSinceLevelLoad(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Time.timeSinceLevelLoad); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_timeSinceLevelLoadAsDouble(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Time.timeSinceLevelLoadAsDouble); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_deltaTime(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Time.deltaTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fixedTime(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Time.fixedTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fixedTimeAsDouble(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Time.fixedTimeAsDouble); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_unscaledTime(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Time.unscaledTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_unscaledTimeAsDouble(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Time.unscaledTimeAsDouble); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fixedUnscaledTime(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Time.fixedUnscaledTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fixedUnscaledTimeAsDouble(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Time.fixedUnscaledTimeAsDouble); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_unscaledDeltaTime(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Time.unscaledDeltaTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fixedUnscaledDeltaTime(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Time.fixedUnscaledDeltaTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fixedDeltaTime(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Time.fixedDeltaTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maximumDeltaTime(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Time.maximumDeltaTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_smoothDeltaTime(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Time.smoothDeltaTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maximumParticleDeltaTime(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Time.maximumParticleDeltaTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_timeScale(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Time.timeScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_frameCount(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.Time.frameCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_renderedFrameCount(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.Time.renderedFrameCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_realtimeSinceStartup(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Time.realtimeSinceStartup); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_realtimeSinceStartupAsDouble(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Time.realtimeSinceStartupAsDouble); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_captureDeltaTime(RealStatePtr L) + { + try { + + LuaAPI.lua_pushnumber(L, UnityEngine.Time.captureDeltaTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_captureFramerate(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.Time.captureFramerate); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_inFixedTimeStep(RealStatePtr L) + { + try { + + LuaAPI.lua_pushboolean(L, UnityEngine.Time.inFixedTimeStep); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_fixedDeltaTime(RealStatePtr L) + { + try { + + UnityEngine.Time.fixedDeltaTime = (float)LuaAPI.lua_tonumber(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_maximumDeltaTime(RealStatePtr L) + { + try { + + UnityEngine.Time.maximumDeltaTime = (float)LuaAPI.lua_tonumber(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_maximumParticleDeltaTime(RealStatePtr L) + { + try { + + UnityEngine.Time.maximumParticleDeltaTime = (float)LuaAPI.lua_tonumber(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_timeScale(RealStatePtr L) + { + try { + + UnityEngine.Time.timeScale = (float)LuaAPI.lua_tonumber(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_captureDeltaTime(RealStatePtr L) + { + try { + + UnityEngine.Time.captureDeltaTime = (float)LuaAPI.lua_tonumber(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_captureFramerate(RealStatePtr L) + { + try { + + UnityEngine.Time.captureFramerate = LuaAPI.xlua_tointeger(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_TransformWrap.cs b/Assets/XLua/Gen/UnityEngine_TransformWrap.cs new file mode 100644 index 000000000..d6ebf387b --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_TransformWrap.cs @@ -0,0 +1,3594 @@ +#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; +using DG.Tweening; + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class UnityEngineTransformWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Transform); + Utils.BeginObjectRegister(type, L, translator, 0, 57, 19, 13); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetParent", _m_SetParent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPositionAndRotation", _m_SetPositionAndRotation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLocalPositionAndRotation", _m_SetLocalPositionAndRotation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPositionAndRotation", _m_GetPositionAndRotation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetLocalPositionAndRotation", _m_GetLocalPositionAndRotation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Translate", _m_Translate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Rotate", _m_Rotate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RotateAround", _m_RotateAround); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LookAt", _m_LookAt); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TransformDirection", _m_TransformDirection); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InverseTransformDirection", _m_InverseTransformDirection); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TransformVector", _m_TransformVector); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InverseTransformVector", _m_InverseTransformVector); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "TransformPoint", _m_TransformPoint); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "InverseTransformPoint", _m_InverseTransformPoint); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DetachChildren", _m_DetachChildren); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAsFirstSibling", _m_SetAsFirstSibling); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAsLastSibling", _m_SetAsLastSibling); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSiblingIndex", _m_SetSiblingIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSiblingIndex", _m_GetSiblingIndex); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Find", _m_Find); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsChildOf", _m_IsChildOf); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetEnumerator", _m_GetEnumerator); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetChild", _m_GetChild); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOMove", _m_DOMove); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOMoveX", _m_DOMoveX); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOMoveY", _m_DOMoveY); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOMoveZ", _m_DOMoveZ); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOLocalMove", _m_DOLocalMove); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOLocalMoveX", _m_DOLocalMoveX); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOLocalMoveY", _m_DOLocalMoveY); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOLocalMoveZ", _m_DOLocalMoveZ); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DORotate", _m_DORotate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DORotateQuaternion", _m_DORotateQuaternion); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOLocalRotate", _m_DOLocalRotate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOLocalRotateQuaternion", _m_DOLocalRotateQuaternion); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOScale", _m_DOScale); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOScaleX", _m_DOScaleX); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOScaleY", _m_DOScaleY); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOScaleZ", _m_DOScaleZ); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOLookAt", _m_DOLookAt); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOPunchPosition", _m_DOPunchPosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOPunchScale", _m_DOPunchScale); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOPunchRotation", _m_DOPunchRotation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOShakePosition", _m_DOShakePosition); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOShakeRotation", _m_DOShakeRotation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOShakeScale", _m_DOShakeScale); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOJump", _m_DOJump); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOLocalJump", _m_DOLocalJump); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOPath", _m_DOPath); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOLocalPath", _m_DOLocalPath); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOBlendableMoveBy", _m_DOBlendableMoveBy); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOBlendableLocalMoveBy", _m_DOBlendableLocalMoveBy); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOBlendableRotateBy", _m_DOBlendableRotateBy); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOBlendableLocalRotateBy", _m_DOBlendableLocalRotateBy); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOBlendablePunchRotation", _m_DOBlendablePunchRotation); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOBlendableScaleBy", _m_DOBlendableScaleBy); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "position", _g_get_position); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "localPosition", _g_get_localPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "eulerAngles", _g_get_eulerAngles); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "localEulerAngles", _g_get_localEulerAngles); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "right", _g_get_right); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "up", _g_get_up); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "forward", _g_get_forward); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rotation", _g_get_rotation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "localRotation", _g_get_localRotation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "localScale", _g_get_localScale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "parent", _g_get_parent); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "worldToLocalMatrix", _g_get_worldToLocalMatrix); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "localToWorldMatrix", _g_get_localToWorldMatrix); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "root", _g_get_root); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "childCount", _g_get_childCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lossyScale", _g_get_lossyScale); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "hasChanged", _g_get_hasChanged); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "hierarchyCapacity", _g_get_hierarchyCapacity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "hierarchyCount", _g_get_hierarchyCount); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "position", _s_set_position); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "localPosition", _s_set_localPosition); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "eulerAngles", _s_set_eulerAngles); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "localEulerAngles", _s_set_localEulerAngles); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "right", _s_set_right); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "up", _s_set_up); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "forward", _s_set_forward); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "rotation", _s_set_rotation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "localRotation", _s_set_localRotation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "localScale", _s_set_localScale); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "parent", _s_set_parent); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "hasChanged", _s_set_hasChanged); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "hierarchyCapacity", _s_set_hierarchyCapacity); + + + 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, "UnityEngine.Transform does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetParent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Transform _p = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + + gen_to_be_invoked.SetParent( _p ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Transform _parent = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + bool _worldPositionStays = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.SetParent( _parent, _worldPositionStays ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Transform.SetParent!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetPositionAndRotation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + UnityEngine.Quaternion _rotation;translator.Get(L, 3, out _rotation); + + gen_to_be_invoked.SetPositionAndRotation( _position, _rotation ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLocalPositionAndRotation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector3 _localPosition;translator.Get(L, 2, out _localPosition); + UnityEngine.Quaternion _localRotation;translator.Get(L, 3, out _localRotation); + + gen_to_be_invoked.SetLocalPositionAndRotation( _localPosition, _localRotation ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetPositionAndRotation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector3 _position; + UnityEngine.Quaternion _rotation; + + gen_to_be_invoked.GetPositionAndRotation( out _position, out _rotation ); + translator.PushUnityEngineVector3(L, _position); + + translator.PushUnityEngineQuaternion(L, _rotation); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetLocalPositionAndRotation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector3 _localPosition; + UnityEngine.Quaternion _localRotation; + + gen_to_be_invoked.GetLocalPositionAndRotation( out _localPosition, out _localRotation ); + translator.PushUnityEngineVector3(L, _localPosition); + + translator.PushUnityEngineQuaternion(L, _localRotation); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Translate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.Translate( _x, _y, _z ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _translation;translator.Get(L, 2, out _translation); + + gen_to_be_invoked.Translate( _translation ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + UnityEngine.Space _relativeTo;translator.Get(L, 5, out _relativeTo); + + gen_to_be_invoked.Translate( _x, _y, _z, _relativeTo ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + UnityEngine.Transform _relativeTo = (UnityEngine.Transform)translator.GetObject(L, 5, typeof(UnityEngine.Transform)); + + gen_to_be_invoked.Translate( _x, _y, _z, _relativeTo ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _translation;translator.Get(L, 2, out _translation); + UnityEngine.Space _relativeTo;translator.Get(L, 3, out _relativeTo); + + gen_to_be_invoked.Translate( _translation, _relativeTo ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _translation;translator.Get(L, 2, out _translation); + UnityEngine.Transform _relativeTo = (UnityEngine.Transform)translator.GetObject(L, 3, typeof(UnityEngine.Transform)); + + gen_to_be_invoked.Translate( _translation, _relativeTo ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Transform.Translate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Rotate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _xAngle = (float)LuaAPI.lua_tonumber(L, 2); + float _yAngle = (float)LuaAPI.lua_tonumber(L, 3); + float _zAngle = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.Rotate( _xAngle, _yAngle, _zAngle ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _eulers;translator.Get(L, 2, out _eulers); + + gen_to_be_invoked.Rotate( _eulers ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _axis;translator.Get(L, 2, out _axis); + float _angle = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.Rotate( _axis, _angle ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + float _xAngle = (float)LuaAPI.lua_tonumber(L, 2); + float _yAngle = (float)LuaAPI.lua_tonumber(L, 3); + float _zAngle = (float)LuaAPI.lua_tonumber(L, 4); + UnityEngine.Space _relativeTo;translator.Get(L, 5, out _relativeTo); + + gen_to_be_invoked.Rotate( _xAngle, _yAngle, _zAngle, _relativeTo ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _eulers;translator.Get(L, 2, out _eulers); + UnityEngine.Space _relativeTo;translator.Get(L, 3, out _relativeTo); + + gen_to_be_invoked.Rotate( _eulers, _relativeTo ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Vector3 _axis;translator.Get(L, 2, out _axis); + float _angle = (float)LuaAPI.lua_tonumber(L, 3); + UnityEngine.Space _relativeTo;translator.Get(L, 4, out _relativeTo); + + gen_to_be_invoked.Rotate( _axis, _angle, _relativeTo ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Transform.Rotate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RotateAround(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector3 _point;translator.Get(L, 2, out _point); + UnityEngine.Vector3 _axis;translator.Get(L, 3, out _axis); + float _angle = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.RotateAround( _point, _axis, _angle ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LookAt(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Transform _target = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + + gen_to_be_invoked.LookAt( _target ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _worldPosition;translator.Get(L, 2, out _worldPosition); + + gen_to_be_invoked.LookAt( _worldPosition ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Transform _target = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + UnityEngine.Vector3 _worldUp;translator.Get(L, 3, out _worldUp); + + gen_to_be_invoked.LookAt( _target, _worldUp ); + + + + return 0; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _worldPosition;translator.Get(L, 2, out _worldPosition); + UnityEngine.Vector3 _worldUp;translator.Get(L, 3, out _worldUp); + + gen_to_be_invoked.LookAt( _worldPosition, _worldUp ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Transform.LookAt!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TransformDirection(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.TransformDirection( _x, _y, _z ); + translator.PushUnityEngineVector3(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _direction;translator.Get(L, 2, out _direction); + + var gen_ret = gen_to_be_invoked.TransformDirection( _direction ); + translator.PushUnityEngineVector3(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 UnityEngine.Transform.TransformDirection!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_InverseTransformDirection(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.InverseTransformDirection( _x, _y, _z ); + translator.PushUnityEngineVector3(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _direction;translator.Get(L, 2, out _direction); + + var gen_ret = gen_to_be_invoked.InverseTransformDirection( _direction ); + translator.PushUnityEngineVector3(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 UnityEngine.Transform.InverseTransformDirection!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TransformVector(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.TransformVector( _x, _y, _z ); + translator.PushUnityEngineVector3(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _vector;translator.Get(L, 2, out _vector); + + var gen_ret = gen_to_be_invoked.TransformVector( _vector ); + translator.PushUnityEngineVector3(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 UnityEngine.Transform.TransformVector!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_InverseTransformVector(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.InverseTransformVector( _x, _y, _z ); + translator.PushUnityEngineVector3(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _vector;translator.Get(L, 2, out _vector); + + var gen_ret = gen_to_be_invoked.InverseTransformVector( _vector ); + translator.PushUnityEngineVector3(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 UnityEngine.Transform.InverseTransformVector!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TransformPoint(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.TransformPoint( _x, _y, _z ); + translator.PushUnityEngineVector3(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + + var gen_ret = gen_to_be_invoked.TransformPoint( _position ); + translator.PushUnityEngineVector3(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 UnityEngine.Transform.TransformPoint!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_InverseTransformPoint(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.InverseTransformPoint( _x, _y, _z ); + translator.PushUnityEngineVector3(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _position;translator.Get(L, 2, out _position); + + var gen_ret = gen_to_be_invoked.InverseTransformPoint( _position ); + translator.PushUnityEngineVector3(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 UnityEngine.Transform.InverseTransformPoint!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DetachChildren(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.DetachChildren( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAsFirstSibling(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetAsFirstSibling( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAsLastSibling(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetAsLastSibling( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetSiblingIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetSiblingIndex( _index ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetSiblingIndex(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetSiblingIndex( ); + 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_Find(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + + { + string _n = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.Find( _n ); + 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_IsChildOf(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Transform _parent = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + + var gen_ret = gen_to_be_invoked.IsChildOf( _parent ); + 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_GetEnumerator(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetEnumerator( ); + 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_GetChild(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + + { + int _index = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetChild( _index ); + 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_DOMove(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapping = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.DOMove( _endValue, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOMove( _endValue, _duration ); + 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 UnityEngine.Transform.DOMove!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOMoveX(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapping = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.DOMoveX( _endValue, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOMoveX( _endValue, _duration ); + 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 UnityEngine.Transform.DOMoveX!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOMoveY(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapping = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.DOMoveY( _endValue, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOMoveY( _endValue, _duration ); + 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 UnityEngine.Transform.DOMoveY!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOMoveZ(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapping = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.DOMoveZ( _endValue, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOMoveZ( _endValue, _duration ); + 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 UnityEngine.Transform.DOMoveZ!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOLocalMove(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapping = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.DOLocalMove( _endValue, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOLocalMove( _endValue, _duration ); + 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 UnityEngine.Transform.DOLocalMove!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOLocalMoveX(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapping = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.DOLocalMoveX( _endValue, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOLocalMoveX( _endValue, _duration ); + 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 UnityEngine.Transform.DOLocalMoveX!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOLocalMoveY(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapping = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.DOLocalMoveY( _endValue, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOLocalMoveY( _endValue, _duration ); + 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 UnityEngine.Transform.DOLocalMoveY!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOLocalMoveZ(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapping = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.DOLocalMoveZ( _endValue, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOLocalMoveZ( _endValue, _duration ); + 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 UnityEngine.Transform.DOLocalMoveZ!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DORotate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Vector3 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + DG.Tweening.RotateMode _mode;translator.Get(L, 4, out _mode); + + var gen_ret = gen_to_be_invoked.DORotate( _endValue, _duration, _mode ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DORotate( _endValue, _duration ); + 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 UnityEngine.Transform.DORotate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DORotateQuaternion(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Quaternion _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DORotateQuaternion( _endValue, _duration ); + 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_DOLocalRotate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Vector3 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + DG.Tweening.RotateMode _mode;translator.Get(L, 4, out _mode); + + var gen_ret = gen_to_be_invoked.DOLocalRotate( _endValue, _duration, _mode ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOLocalRotate( _endValue, _duration ); + 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 UnityEngine.Transform.DOLocalRotate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOLocalRotateQuaternion(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Quaternion _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOLocalRotateQuaternion( _endValue, _duration ); + 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_DOScale(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOScale( _endValue, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOScale( _endValue, _duration ); + 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 UnityEngine.Transform.DOScale!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOScaleX(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOScaleX( _endValue, _duration ); + 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_DOScaleY(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOScaleY( _endValue, _duration ); + 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_DOScaleZ(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOScaleZ( _endValue, _duration ); + 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_DOLookAt(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable>(L, 5)) + { + UnityEngine.Vector3 _towards;translator.Get(L, 2, out _towards); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + DG.Tweening.AxisConstraint _axisConstraint;translator.Get(L, 4, out _axisConstraint); + System.Nullable _up;translator.Get(L, 5, out _up); + + var gen_ret = gen_to_be_invoked.DOLookAt( _towards, _duration, _axisConstraint, _up ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Vector3 _towards;translator.Get(L, 2, out _towards); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + DG.Tweening.AxisConstraint _axisConstraint;translator.Get(L, 4, out _axisConstraint); + + var gen_ret = gen_to_be_invoked.DOLookAt( _towards, _duration, _axisConstraint ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _towards;translator.Get(L, 2, out _towards); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOLookAt( _towards, _duration ); + 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 UnityEngine.Transform.DOLookAt!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOPunchPosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 6&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Vector3 _punch;translator.Get(L, 2, out _punch); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _elasticity = (float)LuaAPI.lua_tonumber(L, 5); + bool _snapping = LuaAPI.lua_toboolean(L, 6); + + var gen_ret = gen_to_be_invoked.DOPunchPosition( _punch, _duration, _vibrato, _elasticity, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Vector3 _punch;translator.Get(L, 2, out _punch); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _elasticity = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = gen_to_be_invoked.DOPunchPosition( _punch, _duration, _vibrato, _elasticity ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3 _punch;translator.Get(L, 2, out _punch); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.DOPunchPosition( _punch, _duration, _vibrato ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _punch;translator.Get(L, 2, out _punch); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOPunchPosition( _punch, _duration ); + 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 UnityEngine.Transform.DOPunchPosition!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOPunchScale(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Vector3 _punch;translator.Get(L, 2, out _punch); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _elasticity = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = gen_to_be_invoked.DOPunchScale( _punch, _duration, _vibrato, _elasticity ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3 _punch;translator.Get(L, 2, out _punch); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.DOPunchScale( _punch, _duration, _vibrato ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _punch;translator.Get(L, 2, out _punch); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOPunchScale( _punch, _duration ); + 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 UnityEngine.Transform.DOPunchScale!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOPunchRotation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Vector3 _punch;translator.Get(L, 2, out _punch); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _elasticity = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = gen_to_be_invoked.DOPunchRotation( _punch, _duration, _vibrato, _elasticity ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3 _punch;translator.Get(L, 2, out _punch); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.DOPunchRotation( _punch, _duration, _vibrato ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _punch;translator.Get(L, 2, out _punch); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOPunchRotation( _punch, _duration ); + 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 UnityEngine.Transform.DOPunchRotation!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOShakePosition(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 7&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 7)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + float _strength = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _randomness = (float)LuaAPI.lua_tonumber(L, 5); + bool _snapping = LuaAPI.lua_toboolean(L, 6); + bool _fadeOut = LuaAPI.lua_toboolean(L, 7); + + var gen_ret = gen_to_be_invoked.DOShakePosition( _duration, _strength, _vibrato, _randomness, _snapping, _fadeOut ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + float _strength = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _randomness = (float)LuaAPI.lua_tonumber(L, 5); + bool _snapping = LuaAPI.lua_toboolean(L, 6); + + var gen_ret = gen_to_be_invoked.DOShakePosition( _duration, _strength, _vibrato, _randomness, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + float _strength = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _randomness = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = gen_to_be_invoked.DOShakePosition( _duration, _strength, _vibrato, _randomness ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + float _strength = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.DOShakePosition( _duration, _strength, _vibrato ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + float _strength = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOShakePosition( _duration, _strength ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.DOShakePosition( _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 7&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 7)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _strength;translator.Get(L, 3, out _strength); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _randomness = (float)LuaAPI.lua_tonumber(L, 5); + bool _snapping = LuaAPI.lua_toboolean(L, 6); + bool _fadeOut = LuaAPI.lua_toboolean(L, 7); + + var gen_ret = gen_to_be_invoked.DOShakePosition( _duration, _strength, _vibrato, _randomness, _snapping, _fadeOut ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _strength;translator.Get(L, 3, out _strength); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _randomness = (float)LuaAPI.lua_tonumber(L, 5); + bool _snapping = LuaAPI.lua_toboolean(L, 6); + + var gen_ret = gen_to_be_invoked.DOShakePosition( _duration, _strength, _vibrato, _randomness, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _strength;translator.Get(L, 3, out _strength); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _randomness = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = gen_to_be_invoked.DOShakePosition( _duration, _strength, _vibrato, _randomness ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _strength;translator.Get(L, 3, out _strength); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.DOShakePosition( _duration, _strength, _vibrato ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _strength;translator.Get(L, 3, out _strength); + + var gen_ret = gen_to_be_invoked.DOShakePosition( _duration, _strength ); + 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 UnityEngine.Transform.DOShakePosition!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOShakeRotation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + float _strength = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _randomness = (float)LuaAPI.lua_tonumber(L, 5); + bool _fadeOut = LuaAPI.lua_toboolean(L, 6); + + var gen_ret = gen_to_be_invoked.DOShakeRotation( _duration, _strength, _vibrato, _randomness, _fadeOut ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + float _strength = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _randomness = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = gen_to_be_invoked.DOShakeRotation( _duration, _strength, _vibrato, _randomness ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + float _strength = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.DOShakeRotation( _duration, _strength, _vibrato ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + float _strength = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOShakeRotation( _duration, _strength ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.DOShakeRotation( _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _strength;translator.Get(L, 3, out _strength); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _randomness = (float)LuaAPI.lua_tonumber(L, 5); + bool _fadeOut = LuaAPI.lua_toboolean(L, 6); + + var gen_ret = gen_to_be_invoked.DOShakeRotation( _duration, _strength, _vibrato, _randomness, _fadeOut ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _strength;translator.Get(L, 3, out _strength); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _randomness = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = gen_to_be_invoked.DOShakeRotation( _duration, _strength, _vibrato, _randomness ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _strength;translator.Get(L, 3, out _strength); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.DOShakeRotation( _duration, _strength, _vibrato ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _strength;translator.Get(L, 3, out _strength); + + var gen_ret = gen_to_be_invoked.DOShakeRotation( _duration, _strength ); + 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 UnityEngine.Transform.DOShakeRotation!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOShakeScale(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + float _strength = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _randomness = (float)LuaAPI.lua_tonumber(L, 5); + bool _fadeOut = LuaAPI.lua_toboolean(L, 6); + + var gen_ret = gen_to_be_invoked.DOShakeScale( _duration, _strength, _vibrato, _randomness, _fadeOut ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + float _strength = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _randomness = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = gen_to_be_invoked.DOShakeScale( _duration, _strength, _vibrato, _randomness ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + float _strength = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.DOShakeScale( _duration, _strength, _vibrato ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + float _strength = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOShakeScale( _duration, _strength ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.DOShakeScale( _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _strength;translator.Get(L, 3, out _strength); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _randomness = (float)LuaAPI.lua_tonumber(L, 5); + bool _fadeOut = LuaAPI.lua_toboolean(L, 6); + + var gen_ret = gen_to_be_invoked.DOShakeScale( _duration, _strength, _vibrato, _randomness, _fadeOut ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _strength;translator.Get(L, 3, out _strength); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _randomness = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = gen_to_be_invoked.DOShakeScale( _duration, _strength, _vibrato, _randomness ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _strength;translator.Get(L, 3, out _strength); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.DOShakeScale( _duration, _strength, _vibrato ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable(L, 3)) + { + float _duration = (float)LuaAPI.lua_tonumber(L, 2); + UnityEngine.Vector3 _strength;translator.Get(L, 3, out _strength); + + var gen_ret = gen_to_be_invoked.DOShakeScale( _duration, _strength ); + 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 UnityEngine.Transform.DOShakeScale!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOJump(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 6&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Vector3 _endValue;translator.Get(L, 2, out _endValue); + float _jumpPower = (float)LuaAPI.lua_tonumber(L, 3); + int _numJumps = LuaAPI.xlua_tointeger(L, 4); + float _duration = (float)LuaAPI.lua_tonumber(L, 5); + bool _snapping = LuaAPI.lua_toboolean(L, 6); + + var gen_ret = gen_to_be_invoked.DOJump( _endValue, _jumpPower, _numJumps, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Vector3 _endValue;translator.Get(L, 2, out _endValue); + float _jumpPower = (float)LuaAPI.lua_tonumber(L, 3); + int _numJumps = LuaAPI.xlua_tointeger(L, 4); + float _duration = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = gen_to_be_invoked.DOJump( _endValue, _jumpPower, _numJumps, _duration ); + 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 UnityEngine.Transform.DOJump!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOLocalJump(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 6&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Vector3 _endValue;translator.Get(L, 2, out _endValue); + float _jumpPower = (float)LuaAPI.lua_tonumber(L, 3); + int _numJumps = LuaAPI.xlua_tointeger(L, 4); + float _duration = (float)LuaAPI.lua_tonumber(L, 5); + bool _snapping = LuaAPI.lua_toboolean(L, 6); + + var gen_ret = gen_to_be_invoked.DOLocalJump( _endValue, _jumpPower, _numJumps, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Vector3 _endValue;translator.Get(L, 2, out _endValue); + float _jumpPower = (float)LuaAPI.lua_tonumber(L, 3); + int _numJumps = LuaAPI.xlua_tointeger(L, 4); + float _duration = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = gen_to_be_invoked.DOLocalJump( _endValue, _jumpPower, _numJumps, _duration ); + 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 UnityEngine.Transform.DOLocalJump!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOPath(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + DG.Tweening.Plugins.Core.PathCore.Path _path = (DG.Tweening.Plugins.Core.PathCore.Path)translator.GetObject(L, 2, typeof(DG.Tweening.Plugins.Core.PathCore.Path)); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + DG.Tweening.PathMode _pathMode;translator.Get(L, 4, out _pathMode); + + var gen_ret = gen_to_be_invoked.DOPath( _path, _duration, _pathMode ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.Plugins.Core.PathCore.Path _path = (DG.Tweening.Plugins.Core.PathCore.Path)translator.GetObject(L, 2, typeof(DG.Tweening.Plugins.Core.PathCore.Path)); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOPath( _path, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 7&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable>(L, 7)) + { + UnityEngine.Vector3[] _path = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + DG.Tweening.PathType _pathType;translator.Get(L, 4, out _pathType); + DG.Tweening.PathMode _pathMode;translator.Get(L, 5, out _pathMode); + int _resolution = LuaAPI.xlua_tointeger(L, 6); + System.Nullable _gizmoColor;translator.Get(L, 7, out _gizmoColor); + + var gen_ret = gen_to_be_invoked.DOPath( _path, _duration, _pathType, _pathMode, _resolution, _gizmoColor ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Vector3[] _path = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + DG.Tweening.PathType _pathType;translator.Get(L, 4, out _pathType); + DG.Tweening.PathMode _pathMode;translator.Get(L, 5, out _pathMode); + int _resolution = LuaAPI.xlua_tointeger(L, 6); + + var gen_ret = gen_to_be_invoked.DOPath( _path, _duration, _pathType, _pathMode, _resolution ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)) + { + UnityEngine.Vector3[] _path = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + DG.Tweening.PathType _pathType;translator.Get(L, 4, out _pathType); + DG.Tweening.PathMode _pathMode;translator.Get(L, 5, out _pathMode); + + var gen_ret = gen_to_be_invoked.DOPath( _path, _duration, _pathType, _pathMode ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Vector3[] _path = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + DG.Tweening.PathType _pathType;translator.Get(L, 4, out _pathType); + + var gen_ret = gen_to_be_invoked.DOPath( _path, _duration, _pathType ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3[] _path = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOPath( _path, _duration ); + 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 UnityEngine.Transform.DOPath!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOLocalPath(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + DG.Tweening.Plugins.Core.PathCore.Path _path = (DG.Tweening.Plugins.Core.PathCore.Path)translator.GetObject(L, 2, typeof(DG.Tweening.Plugins.Core.PathCore.Path)); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + DG.Tweening.PathMode _pathMode;translator.Get(L, 4, out _pathMode); + + var gen_ret = gen_to_be_invoked.DOLocalPath( _path, _duration, _pathMode ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + DG.Tweening.Plugins.Core.PathCore.Path _path = (DG.Tweening.Plugins.Core.PathCore.Path)translator.GetObject(L, 2, typeof(DG.Tweening.Plugins.Core.PathCore.Path)); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOLocalPath( _path, _duration ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 7&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)&& translator.Assignable>(L, 7)) + { + UnityEngine.Vector3[] _path = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + DG.Tweening.PathType _pathType;translator.Get(L, 4, out _pathType); + DG.Tweening.PathMode _pathMode;translator.Get(L, 5, out _pathMode); + int _resolution = LuaAPI.xlua_tointeger(L, 6); + System.Nullable _gizmoColor;translator.Get(L, 7, out _gizmoColor); + + var gen_ret = gen_to_be_invoked.DOLocalPath( _path, _duration, _pathType, _pathMode, _resolution, _gizmoColor ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 6&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Vector3[] _path = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + DG.Tweening.PathType _pathType;translator.Get(L, 4, out _pathType); + DG.Tweening.PathMode _pathMode;translator.Get(L, 5, out _pathMode); + int _resolution = LuaAPI.xlua_tointeger(L, 6); + + var gen_ret = gen_to_be_invoked.DOLocalPath( _path, _duration, _pathType, _pathMode, _resolution ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)&& translator.Assignable(L, 5)) + { + UnityEngine.Vector3[] _path = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + DG.Tweening.PathType _pathType;translator.Get(L, 4, out _pathType); + DG.Tweening.PathMode _pathMode;translator.Get(L, 5, out _pathMode); + + var gen_ret = gen_to_be_invoked.DOLocalPath( _path, _duration, _pathType, _pathMode ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Vector3[] _path = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + DG.Tweening.PathType _pathType;translator.Get(L, 4, out _pathType); + + var gen_ret = gen_to_be_invoked.DOLocalPath( _path, _duration, _pathType ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3[] _path = (UnityEngine.Vector3[])translator.GetObject(L, 2, typeof(UnityEngine.Vector3[])); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOLocalPath( _path, _duration ); + 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 UnityEngine.Transform.DOLocalPath!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOBlendableMoveBy(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3 _byValue;translator.Get(L, 2, out _byValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapping = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.DOBlendableMoveBy( _byValue, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _byValue;translator.Get(L, 2, out _byValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOBlendableMoveBy( _byValue, _duration ); + 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 UnityEngine.Transform.DOBlendableMoveBy!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOBlendableLocalMoveBy(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3 _byValue;translator.Get(L, 2, out _byValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapping = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.DOBlendableLocalMoveBy( _byValue, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _byValue;translator.Get(L, 2, out _byValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOBlendableLocalMoveBy( _byValue, _duration ); + 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 UnityEngine.Transform.DOBlendableLocalMoveBy!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOBlendableRotateBy(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Vector3 _byValue;translator.Get(L, 2, out _byValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + DG.Tweening.RotateMode _mode;translator.Get(L, 4, out _mode); + + var gen_ret = gen_to_be_invoked.DOBlendableRotateBy( _byValue, _duration, _mode ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _byValue;translator.Get(L, 2, out _byValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOBlendableRotateBy( _byValue, _duration ); + 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 UnityEngine.Transform.DOBlendableRotateBy!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOBlendableLocalRotateBy(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& translator.Assignable(L, 4)) + { + UnityEngine.Vector3 _byValue;translator.Get(L, 2, out _byValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + DG.Tweening.RotateMode _mode;translator.Get(L, 4, out _mode); + + var gen_ret = gen_to_be_invoked.DOBlendableLocalRotateBy( _byValue, _duration, _mode ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _byValue;translator.Get(L, 2, out _byValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOBlendableLocalRotateBy( _byValue, _duration ); + 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 UnityEngine.Transform.DOBlendableLocalRotateBy!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOBlendablePunchRotation(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Vector3 _punch;translator.Get(L, 2, out _punch); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + float _elasticity = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = gen_to_be_invoked.DOBlendablePunchRotation( _punch, _duration, _vibrato, _elasticity ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3 _punch;translator.Get(L, 2, out _punch); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + int _vibrato = LuaAPI.xlua_tointeger(L, 4); + + var gen_ret = gen_to_be_invoked.DOBlendablePunchRotation( _punch, _duration, _vibrato ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector3 _punch;translator.Get(L, 2, out _punch); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOBlendablePunchRotation( _punch, _duration ); + 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 UnityEngine.Transform.DOBlendablePunchRotation!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOBlendableScaleBy(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector3 _byValue;translator.Get(L, 2, out _byValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOBlendableScaleBy( _byValue, _duration ); + 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_position(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.position); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_localPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.localPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_eulerAngles(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.eulerAngles); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_localEulerAngles(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.localEulerAngles); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_right(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.right); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_up(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.up); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_forward(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.forward); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineQuaternion(L, gen_to_be_invoked.rotation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_localRotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineQuaternion(L, gen_to_be_invoked.localRotation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_localScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.localScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_parent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.parent); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_worldToLocalMatrix(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.worldToLocalMatrix); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_localToWorldMatrix(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.localToWorldMatrix); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_root(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.root); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_childCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.childCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lossyScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.lossyScale); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_hasChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hasChanged); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_hierarchyCapacity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.hierarchyCapacity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_hierarchyCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.hierarchyCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_position(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.position = 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_localPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.localPosition = 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_eulerAngles(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.eulerAngles = 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_localEulerAngles(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.localEulerAngles = 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_right(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.right = 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_up(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.up = 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_forward(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.forward = 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_rotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + UnityEngine.Quaternion gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.rotation = 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_localRotation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + UnityEngine.Quaternion gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.localRotation = 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_localScale(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + UnityEngine.Vector3 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.localScale = 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_parent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.parent = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_hasChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.hasChanged = 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_hierarchyCapacity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.hierarchyCapacity = 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/UnityEngine_U2D_SpriteAtlasWrap.cs b/Assets/XLua/Gen/UnityEngine_U2D_SpriteAtlasWrap.cs new file mode 100644 index 000000000..f93f17829 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_U2D_SpriteAtlasWrap.cs @@ -0,0 +1,235 @@ +#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 UnityEngineU2DSpriteAtlasWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.U2D.SpriteAtlas); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 3, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CanBindTo", _m_CanBindTo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSprite", _m_GetSprite); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSprites", _m_GetSprites); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isVariant", _g_get_isVariant); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "tag", _g_get_tag); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "spriteCount", _g_get_spriteCount); + + + + 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 UnityEngine.U2D.SpriteAtlas(); + 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 UnityEngine.U2D.SpriteAtlas constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CanBindTo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.U2D.SpriteAtlas gen_to_be_invoked = (UnityEngine.U2D.SpriteAtlas)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Sprite _sprite = (UnityEngine.Sprite)translator.GetObject(L, 2, typeof(UnityEngine.Sprite)); + + var gen_ret = gen_to_be_invoked.CanBindTo( _sprite ); + 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_GetSprite(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.U2D.SpriteAtlas gen_to_be_invoked = (UnityEngine.U2D.SpriteAtlas)translator.FastGetCSObj(L, 1); + + + + { + string _name = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.GetSprite( _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_GetSprites(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.U2D.SpriteAtlas gen_to_be_invoked = (UnityEngine.U2D.SpriteAtlas)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Sprite[] _sprites = (UnityEngine.Sprite[])translator.GetObject(L, 2, typeof(UnityEngine.Sprite[])); + + var gen_ret = gen_to_be_invoked.GetSprites( _sprites ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + UnityEngine.Sprite[] _sprites = (UnityEngine.Sprite[])translator.GetObject(L, 2, typeof(UnityEngine.Sprite[])); + string _name = LuaAPI.lua_tostring(L, 3); + + var gen_ret = gen_to_be_invoked.GetSprites( _sprites, _name ); + LuaAPI.xlua_pushinteger(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 UnityEngine.U2D.SpriteAtlas.GetSprites!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isVariant(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.U2D.SpriteAtlas gen_to_be_invoked = (UnityEngine.U2D.SpriteAtlas)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isVariant); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_tag(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.U2D.SpriteAtlas gen_to_be_invoked = (UnityEngine.U2D.SpriteAtlas)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.tag); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_spriteCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.U2D.SpriteAtlas gen_to_be_invoked = (UnityEngine.U2D.SpriteAtlas)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.spriteCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_UI_ButtonWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_ButtonWrap.cs new file mode 100644 index 000000000..8a202b26b --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_ButtonWrap.cs @@ -0,0 +1,156 @@ +#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 UnityEngineUIButtonWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.Button); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 1, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerClick", _m_OnPointerClick); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnSubmit", _m_OnSubmit); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onClick", _g_get_onClick); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onClick", _s_set_onClick); + + + 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, "UnityEngine.UI.Button does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerClick(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Button gen_to_be_invoked = (UnityEngine.UI.Button)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerClick( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnSubmit(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Button gen_to_be_invoked = (UnityEngine.UI.Button)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.BaseEventData _eventData = (UnityEngine.EventSystems.BaseEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.BaseEventData)); + + gen_to_be_invoked.OnSubmit( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onClick(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Button gen_to_be_invoked = (UnityEngine.UI.Button)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onClick); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_onClick(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Button gen_to_be_invoked = (UnityEngine.UI.Button)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onClick = (UnityEngine.UI.Button.ButtonClickedEvent)translator.GetObject(L, 2, typeof(UnityEngine.UI.Button.ButtonClickedEvent)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_UI_Button_ButtonClickedEventWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_Button_ButtonClickedEventWrap.cs new file mode 100644 index 000000000..71ee134ff --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_Button_ButtonClickedEventWrap.cs @@ -0,0 +1,84 @@ +#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 UnityEngineUIButtonButtonClickedEventWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.Button.ButtonClickedEvent); + 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) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new UnityEngine.UI.Button.ButtonClickedEvent(); + 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 UnityEngine.UI.Button.ButtonClickedEvent constructor!"); + + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_UI_CanvasScalerWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_CanvasScalerWrap.cs new file mode 100644 index 000000000..c06bbf713 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_CanvasScalerWrap.cs @@ -0,0 +1,381 @@ +#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 UnityEngineUICanvasScalerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.CanvasScaler); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 10, 10); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "uiScaleMode", _g_get_uiScaleMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "referencePixelsPerUnit", _g_get_referencePixelsPerUnit); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "scaleFactor", _g_get_scaleFactor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "referenceResolution", _g_get_referenceResolution); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "screenMatchMode", _g_get_screenMatchMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "matchWidthOrHeight", _g_get_matchWidthOrHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "physicalUnit", _g_get_physicalUnit); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fallbackScreenDPI", _g_get_fallbackScreenDPI); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "defaultSpriteDPI", _g_get_defaultSpriteDPI); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "dynamicPixelsPerUnit", _g_get_dynamicPixelsPerUnit); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "uiScaleMode", _s_set_uiScaleMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "referencePixelsPerUnit", _s_set_referencePixelsPerUnit); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "scaleFactor", _s_set_scaleFactor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "referenceResolution", _s_set_referenceResolution); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "screenMatchMode", _s_set_screenMatchMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "matchWidthOrHeight", _s_set_matchWidthOrHeight); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "physicalUnit", _s_set_physicalUnit); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fallbackScreenDPI", _s_set_fallbackScreenDPI); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "defaultSpriteDPI", _s_set_defaultSpriteDPI); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "dynamicPixelsPerUnit", _s_set_dynamicPixelsPerUnit); + + + 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, "UnityEngine.UI.CanvasScaler does not have a constructor!"); + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_uiScaleMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.CanvasScaler gen_to_be_invoked = (UnityEngine.UI.CanvasScaler)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.uiScaleMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_referencePixelsPerUnit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.CanvasScaler gen_to_be_invoked = (UnityEngine.UI.CanvasScaler)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.referencePixelsPerUnit); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_scaleFactor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.CanvasScaler gen_to_be_invoked = (UnityEngine.UI.CanvasScaler)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.scaleFactor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_referenceResolution(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.CanvasScaler gen_to_be_invoked = (UnityEngine.UI.CanvasScaler)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.referenceResolution); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_screenMatchMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.CanvasScaler gen_to_be_invoked = (UnityEngine.UI.CanvasScaler)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.screenMatchMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_matchWidthOrHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.CanvasScaler gen_to_be_invoked = (UnityEngine.UI.CanvasScaler)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.matchWidthOrHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_physicalUnit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.CanvasScaler gen_to_be_invoked = (UnityEngine.UI.CanvasScaler)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.physicalUnit); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fallbackScreenDPI(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.CanvasScaler gen_to_be_invoked = (UnityEngine.UI.CanvasScaler)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.fallbackScreenDPI); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_defaultSpriteDPI(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.CanvasScaler gen_to_be_invoked = (UnityEngine.UI.CanvasScaler)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.defaultSpriteDPI); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_dynamicPixelsPerUnit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.CanvasScaler gen_to_be_invoked = (UnityEngine.UI.CanvasScaler)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.dynamicPixelsPerUnit); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_uiScaleMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.CanvasScaler gen_to_be_invoked = (UnityEngine.UI.CanvasScaler)translator.FastGetCSObj(L, 1); + UnityEngine.UI.CanvasScaler.ScaleMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.uiScaleMode = 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_referencePixelsPerUnit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.CanvasScaler gen_to_be_invoked = (UnityEngine.UI.CanvasScaler)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.referencePixelsPerUnit = (float)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_scaleFactor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.CanvasScaler gen_to_be_invoked = (UnityEngine.UI.CanvasScaler)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.scaleFactor = (float)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_referenceResolution(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.CanvasScaler gen_to_be_invoked = (UnityEngine.UI.CanvasScaler)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.referenceResolution = 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_screenMatchMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.CanvasScaler gen_to_be_invoked = (UnityEngine.UI.CanvasScaler)translator.FastGetCSObj(L, 1); + UnityEngine.UI.CanvasScaler.ScreenMatchMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.screenMatchMode = 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_matchWidthOrHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.CanvasScaler gen_to_be_invoked = (UnityEngine.UI.CanvasScaler)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.matchWidthOrHeight = (float)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_physicalUnit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.CanvasScaler gen_to_be_invoked = (UnityEngine.UI.CanvasScaler)translator.FastGetCSObj(L, 1); + UnityEngine.UI.CanvasScaler.Unit gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.physicalUnit = 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_fallbackScreenDPI(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.CanvasScaler gen_to_be_invoked = (UnityEngine.UI.CanvasScaler)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.fallbackScreenDPI = (float)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_defaultSpriteDPI(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.CanvasScaler gen_to_be_invoked = (UnityEngine.UI.CanvasScaler)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.defaultSpriteDPI = (float)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_dynamicPixelsPerUnit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.CanvasScaler gen_to_be_invoked = (UnityEngine.UI.CanvasScaler)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.dynamicPixelsPerUnit = (float)LuaAPI.lua_tonumber(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_UI_DropdownWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_DropdownWrap.cs new file mode 100644 index 000000000..a831851be --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_DropdownWrap.cs @@ -0,0 +1,627 @@ +#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 UnityEngineUIDropdownWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.Dropdown); + Utils.BeginObjectRegister(type, L, translator, 0, 9, 9, 9); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetValueWithoutNotify", _m_SetValueWithoutNotify); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshShownValue", _m_RefreshShownValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddOptions", _m_AddOptions); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearOptions", _m_ClearOptions); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerClick", _m_OnPointerClick); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnSubmit", _m_OnSubmit); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnCancel", _m_OnCancel); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Show", _m_Show); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Hide", _m_Hide); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "template", _g_get_template); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "captionText", _g_get_captionText); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "captionImage", _g_get_captionImage); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "itemText", _g_get_itemText); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "itemImage", _g_get_itemImage); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "options", _g_get_options); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onValueChanged", _g_get_onValueChanged); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "alphaFadeSpeed", _g_get_alphaFadeSpeed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "value", _g_get_value); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "template", _s_set_template); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "captionText", _s_set_captionText); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "captionImage", _s_set_captionImage); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "itemText", _s_set_itemText); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "itemImage", _s_set_itemImage); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "options", _s_set_options); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onValueChanged", _s_set_onValueChanged); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "alphaFadeSpeed", _s_set_alphaFadeSpeed); + 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) + { + return LuaAPI.luaL_error(L, "UnityEngine.UI.Dropdown does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetValueWithoutNotify(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Dropdown gen_to_be_invoked = (UnityEngine.UI.Dropdown)translator.FastGetCSObj(L, 1); + + + + { + int _input = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.SetValueWithoutNotify( _input ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RefreshShownValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Dropdown gen_to_be_invoked = (UnityEngine.UI.Dropdown)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RefreshShownValue( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddOptions(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Dropdown gen_to_be_invoked = (UnityEngine.UI.Dropdown)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.List _options = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.AddOptions( _options ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.List _options = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.AddOptions( _options ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Collections.Generic.List _options = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.AddOptions( _options ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.UI.Dropdown.AddOptions!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ClearOptions(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Dropdown gen_to_be_invoked = (UnityEngine.UI.Dropdown)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ClearOptions( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerClick(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Dropdown gen_to_be_invoked = (UnityEngine.UI.Dropdown)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerClick( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnSubmit(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Dropdown gen_to_be_invoked = (UnityEngine.UI.Dropdown)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.BaseEventData _eventData = (UnityEngine.EventSystems.BaseEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.BaseEventData)); + + gen_to_be_invoked.OnSubmit( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnCancel(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Dropdown gen_to_be_invoked = (UnityEngine.UI.Dropdown)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.BaseEventData _eventData = (UnityEngine.EventSystems.BaseEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.BaseEventData)); + + gen_to_be_invoked.OnCancel( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Show(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Dropdown gen_to_be_invoked = (UnityEngine.UI.Dropdown)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Show( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Hide(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Dropdown gen_to_be_invoked = (UnityEngine.UI.Dropdown)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Hide( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_template(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Dropdown gen_to_be_invoked = (UnityEngine.UI.Dropdown)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.template); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_captionText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Dropdown gen_to_be_invoked = (UnityEngine.UI.Dropdown)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.captionText); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_captionImage(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Dropdown gen_to_be_invoked = (UnityEngine.UI.Dropdown)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.captionImage); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_itemText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Dropdown gen_to_be_invoked = (UnityEngine.UI.Dropdown)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.itemText); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_itemImage(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Dropdown gen_to_be_invoked = (UnityEngine.UI.Dropdown)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.itemImage); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_options(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Dropdown gen_to_be_invoked = (UnityEngine.UI.Dropdown)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.options); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onValueChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Dropdown gen_to_be_invoked = (UnityEngine.UI.Dropdown)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onValueChanged); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_alphaFadeSpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Dropdown gen_to_be_invoked = (UnityEngine.UI.Dropdown)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.alphaFadeSpeed); + } 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); + + UnityEngine.UI.Dropdown gen_to_be_invoked = (UnityEngine.UI.Dropdown)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(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_template(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Dropdown gen_to_be_invoked = (UnityEngine.UI.Dropdown)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.template = (UnityEngine.RectTransform)translator.GetObject(L, 2, typeof(UnityEngine.RectTransform)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_captionText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Dropdown gen_to_be_invoked = (UnityEngine.UI.Dropdown)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.captionText = (UnityEngine.UI.Text)translator.GetObject(L, 2, typeof(UnityEngine.UI.Text)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_captionImage(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Dropdown gen_to_be_invoked = (UnityEngine.UI.Dropdown)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.captionImage = (UnityEngine.UI.Image)translator.GetObject(L, 2, typeof(UnityEngine.UI.Image)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_itemText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Dropdown gen_to_be_invoked = (UnityEngine.UI.Dropdown)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.itemText = (UnityEngine.UI.Text)translator.GetObject(L, 2, typeof(UnityEngine.UI.Text)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_itemImage(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Dropdown gen_to_be_invoked = (UnityEngine.UI.Dropdown)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.itemImage = (UnityEngine.UI.Image)translator.GetObject(L, 2, typeof(UnityEngine.UI.Image)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_options(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Dropdown gen_to_be_invoked = (UnityEngine.UI.Dropdown)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.options = (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; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_onValueChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Dropdown gen_to_be_invoked = (UnityEngine.UI.Dropdown)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onValueChanged = (UnityEngine.UI.Dropdown.DropdownEvent)translator.GetObject(L, 2, typeof(UnityEngine.UI.Dropdown.DropdownEvent)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_alphaFadeSpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Dropdown gen_to_be_invoked = (UnityEngine.UI.Dropdown)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.alphaFadeSpeed = (float)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_value(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Dropdown gen_to_be_invoked = (UnityEngine.UI.Dropdown)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.value = 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/UnityEngine_UI_Dropdown_DropdownEventWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_Dropdown_DropdownEventWrap.cs new file mode 100644 index 000000000..44529849e --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_Dropdown_DropdownEventWrap.cs @@ -0,0 +1,84 @@ +#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 UnityEngineUIDropdownDropdownEventWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.Dropdown.DropdownEvent); + 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) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new UnityEngine.UI.Dropdown.DropdownEvent(); + 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 UnityEngine.UI.Dropdown.DropdownEvent constructor!"); + + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_UI_Dropdown_OptionDataListWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_Dropdown_OptionDataListWrap.cs new file mode 100644 index 000000000..ab9ee9487 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_Dropdown_OptionDataListWrap.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 UnityEngineUIDropdownOptionDataListWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.Dropdown.OptionDataList); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 1, 1); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "options", _g_get_options); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "options", _s_set_options); + + + 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 UnityEngine.UI.Dropdown.OptionDataList(); + 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 UnityEngine.UI.Dropdown.OptionDataList constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_options(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Dropdown.OptionDataList gen_to_be_invoked = (UnityEngine.UI.Dropdown.OptionDataList)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.options); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_options(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Dropdown.OptionDataList gen_to_be_invoked = (UnityEngine.UI.Dropdown.OptionDataList)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.options = (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/UnityEngine_UI_Dropdown_OptionDataWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_Dropdown_OptionDataWrap.cs new file mode 100644 index 000000000..2de1e6398 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_Dropdown_OptionDataWrap.cs @@ -0,0 +1,174 @@ +#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 UnityEngineUIDropdownOptionDataWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.Dropdown.OptionData); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 2); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "text", _g_get_text); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "image", _g_get_image); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "text", _s_set_text); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "image", _s_set_image); + + + 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 UnityEngine.UI.Dropdown.OptionData(); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _text = LuaAPI.lua_tostring(L, 2); + + var gen_ret = new UnityEngine.UI.Dropdown.OptionData(_text); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && translator.Assignable(L, 2)) + { + UnityEngine.Sprite _image = (UnityEngine.Sprite)translator.GetObject(L, 2, typeof(UnityEngine.Sprite)); + + var gen_ret = new UnityEngine.UI.Dropdown.OptionData(_image); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 3 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING) && translator.Assignable(L, 3)) + { + string _text = LuaAPI.lua_tostring(L, 2); + UnityEngine.Sprite _image = (UnityEngine.Sprite)translator.GetObject(L, 3, typeof(UnityEngine.Sprite)); + + var gen_ret = new UnityEngine.UI.Dropdown.OptionData(_text, _image); + 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 UnityEngine.UI.Dropdown.OptionData constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_text(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Dropdown.OptionData gen_to_be_invoked = (UnityEngine.UI.Dropdown.OptionData)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.text); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_image(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Dropdown.OptionData gen_to_be_invoked = (UnityEngine.UI.Dropdown.OptionData)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.image); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_text(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Dropdown.OptionData gen_to_be_invoked = (UnityEngine.UI.Dropdown.OptionData)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.text = 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_image(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Dropdown.OptionData gen_to_be_invoked = (UnityEngine.UI.Dropdown.OptionData)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.image = (UnityEngine.Sprite)translator.GetObject(L, 2, typeof(UnityEngine.Sprite)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_UI_GraphicRaycasterWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_GraphicRaycasterWrap.cs new file mode 100644 index 000000000..5487be91e --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_GraphicRaycasterWrap.cs @@ -0,0 +1,237 @@ +#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 UnityEngineUIGraphicRaycasterWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.GraphicRaycaster); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 6, 3); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Raycast", _m_Raycast); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sortOrderPriority", _g_get_sortOrderPriority); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "renderOrderPriority", _g_get_renderOrderPriority); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ignoreReversedGraphics", _g_get_ignoreReversedGraphics); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "blockingObjects", _g_get_blockingObjects); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "blockingMask", _g_get_blockingMask); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "eventCamera", _g_get_eventCamera); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ignoreReversedGraphics", _s_set_ignoreReversedGraphics); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "blockingObjects", _s_set_blockingObjects); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "blockingMask", _s_set_blockingMask); + + + 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, "UnityEngine.UI.GraphicRaycaster does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Raycast(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.GraphicRaycaster gen_to_be_invoked = (UnityEngine.UI.GraphicRaycaster)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + System.Collections.Generic.List _resultAppendList = (System.Collections.Generic.List)translator.GetObject(L, 3, typeof(System.Collections.Generic.List)); + + gen_to_be_invoked.Raycast( _eventData, _resultAppendList ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sortOrderPriority(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.GraphicRaycaster gen_to_be_invoked = (UnityEngine.UI.GraphicRaycaster)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.sortOrderPriority); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_renderOrderPriority(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.GraphicRaycaster gen_to_be_invoked = (UnityEngine.UI.GraphicRaycaster)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.renderOrderPriority); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ignoreReversedGraphics(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.GraphicRaycaster gen_to_be_invoked = (UnityEngine.UI.GraphicRaycaster)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.ignoreReversedGraphics); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_blockingObjects(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.GraphicRaycaster gen_to_be_invoked = (UnityEngine.UI.GraphicRaycaster)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineUIGraphicRaycasterBlockingObjects(L, gen_to_be_invoked.blockingObjects); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_blockingMask(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.GraphicRaycaster gen_to_be_invoked = (UnityEngine.UI.GraphicRaycaster)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.blockingMask); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_eventCamera(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.GraphicRaycaster gen_to_be_invoked = (UnityEngine.UI.GraphicRaycaster)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.eventCamera); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_ignoreReversedGraphics(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.GraphicRaycaster gen_to_be_invoked = (UnityEngine.UI.GraphicRaycaster)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ignoreReversedGraphics = 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_blockingObjects(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.GraphicRaycaster gen_to_be_invoked = (UnityEngine.UI.GraphicRaycaster)translator.FastGetCSObj(L, 1); + UnityEngine.UI.GraphicRaycaster.BlockingObjects gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.blockingObjects = 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_blockingMask(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.GraphicRaycaster gen_to_be_invoked = (UnityEngine.UI.GraphicRaycaster)translator.FastGetCSObj(L, 1); + UnityEngine.LayerMask gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.blockingMask = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_UI_GraphicWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_GraphicWrap.cs new file mode 100644 index 000000000..07a5ee8f6 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_GraphicWrap.cs @@ -0,0 +1,1030 @@ +#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; +using DG.Tweening; + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class UnityEngineUIGraphicWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.Graphic); + Utils.BeginObjectRegister(type, L, translator, 0, 24, 11, 4); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAllDirty", _m_SetAllDirty); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLayoutDirty", _m_SetLayoutDirty); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetVerticesDirty", _m_SetVerticesDirty); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetMaterialDirty", _m_SetMaterialDirty); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetRaycastDirty", _m_SetRaycastDirty); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnCullingChanged", _m_OnCullingChanged); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Rebuild", _m_Rebuild); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LayoutComplete", _m_LayoutComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GraphicUpdateComplete", _m_GraphicUpdateComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetNativeSize", _m_SetNativeSize); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Raycast", _m_Raycast); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PixelAdjustPoint", _m_PixelAdjustPoint); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPixelAdjustedRect", _m_GetPixelAdjustedRect); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CrossFadeColor", _m_CrossFadeColor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CrossFadeAlpha", _m_CrossFadeAlpha); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RegisterDirtyLayoutCallback", _m_RegisterDirtyLayoutCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnregisterDirtyLayoutCallback", _m_UnregisterDirtyLayoutCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RegisterDirtyVerticesCallback", _m_RegisterDirtyVerticesCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnregisterDirtyVerticesCallback", _m_UnregisterDirtyVerticesCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RegisterDirtyMaterialCallback", _m_RegisterDirtyMaterialCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnregisterDirtyMaterialCallback", _m_UnregisterDirtyMaterialCallback); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOColor", _m_DOColor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOFade", _m_DOFade); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOBlendableColor", _m_DOBlendableColor); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "color", _g_get_color); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "raycastTarget", _g_get_raycastTarget); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "raycastPadding", _g_get_raycastPadding); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "depth", _g_get_depth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rectTransform", _g_get_rectTransform); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "canvas", _g_get_canvas); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "canvasRenderer", _g_get_canvasRenderer); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "defaultMaterial", _g_get_defaultMaterial); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "material", _g_get_material); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "materialForRendering", _g_get_materialForRendering); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mainTexture", _g_get_mainTexture); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "color", _s_set_color); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "raycastTarget", _s_set_raycastTarget); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "raycastPadding", _s_set_raycastPadding); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "material", _s_set_material); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 1, 0); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "defaultGraphicMaterial", _g_get_defaultGraphicMaterial); + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "UnityEngine.UI.Graphic does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetAllDirty(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetAllDirty( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLayoutDirty(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetLayoutDirty( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetVerticesDirty(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetVerticesDirty( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetMaterialDirty(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetMaterialDirty( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetRaycastDirty(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetRaycastDirty( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnCullingChanged(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.OnCullingChanged( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Rebuild(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.UI.CanvasUpdate _update;translator.Get(L, 2, out _update); + + gen_to_be_invoked.Rebuild( _update ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LayoutComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.LayoutComplete( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GraphicUpdateComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.GraphicUpdateComplete( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetNativeSize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetNativeSize( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Raycast(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector2 _sp;translator.Get(L, 2, out _sp); + UnityEngine.Camera _eventCamera = (UnityEngine.Camera)translator.GetObject(L, 3, typeof(UnityEngine.Camera)); + + var gen_ret = gen_to_be_invoked.Raycast( _sp, _eventCamera ); + 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_PixelAdjustPoint(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector2 _point;translator.Get(L, 2, out _point); + + var gen_ret = gen_to_be_invoked.PixelAdjustPoint( _point ); + translator.PushUnityEngineVector2(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_GetPixelAdjustedRect(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetPixelAdjustedRect( ); + 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_CrossFadeColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 5&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Color _targetColor;translator.Get(L, 2, out _targetColor); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _ignoreTimeScale = LuaAPI.lua_toboolean(L, 4); + bool _useAlpha = LuaAPI.lua_toboolean(L, 5); + + gen_to_be_invoked.CrossFadeColor( _targetColor, _duration, _ignoreTimeScale, _useAlpha ); + + + + return 0; + } + if(gen_param_count == 6&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Color _targetColor;translator.Get(L, 2, out _targetColor); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _ignoreTimeScale = LuaAPI.lua_toboolean(L, 4); + bool _useAlpha = LuaAPI.lua_toboolean(L, 5); + bool _useRGB = LuaAPI.lua_toboolean(L, 6); + + gen_to_be_invoked.CrossFadeColor( _targetColor, _duration, _ignoreTimeScale, _useAlpha, _useRGB ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.UI.Graphic.CrossFadeColor!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CrossFadeAlpha(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + + + + { + float _alpha = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _ignoreTimeScale = LuaAPI.lua_toboolean(L, 4); + + gen_to_be_invoked.CrossFadeAlpha( _alpha, _duration, _ignoreTimeScale ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RegisterDirtyLayoutCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Events.UnityAction _action = translator.GetDelegate(L, 2); + + gen_to_be_invoked.RegisterDirtyLayoutCallback( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UnregisterDirtyLayoutCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Events.UnityAction _action = translator.GetDelegate(L, 2); + + gen_to_be_invoked.UnregisterDirtyLayoutCallback( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RegisterDirtyVerticesCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Events.UnityAction _action = translator.GetDelegate(L, 2); + + gen_to_be_invoked.RegisterDirtyVerticesCallback( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UnregisterDirtyVerticesCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Events.UnityAction _action = translator.GetDelegate(L, 2); + + gen_to_be_invoked.UnregisterDirtyVerticesCallback( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RegisterDirtyMaterialCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Events.UnityAction _action = translator.GetDelegate(L, 2); + + gen_to_be_invoked.RegisterDirtyMaterialCallback( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UnregisterDirtyMaterialCallback(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Events.UnityAction _action = translator.GetDelegate(L, 2); + + gen_to_be_invoked.UnregisterDirtyMaterialCallback( _action ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Color _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOColor( _endValue, _duration ); + 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_DOFade(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + + + + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOFade( _endValue, _duration ); + 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_DOBlendableColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Color _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOBlendableColor( _endValue, _duration ); + 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_defaultGraphicMaterial(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.UI.Graphic.defaultGraphicMaterial); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_color(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineColor(L, gen_to_be_invoked.color); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_raycastTarget(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.raycastTarget); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_raycastPadding(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector4(L, gen_to_be_invoked.raycastPadding); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_depth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.depth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rectTransform(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.rectTransform); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_canvas(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.canvas); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_canvasRenderer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.canvasRenderer); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_defaultMaterial(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.defaultMaterial); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_material(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.material); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_materialForRendering(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.materialForRendering); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mainTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.mainTexture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_color(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + UnityEngine.Color gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.color = 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_raycastTarget(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.raycastTarget = 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_raycastPadding(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + UnityEngine.Vector4 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.raycastPadding = 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_material(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Graphic gen_to_be_invoked = (UnityEngine.UI.Graphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.material = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_UI_GridLayoutGroupWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_GridLayoutGroupWrap.cs new file mode 100644 index 000000000..b324d5375 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_GridLayoutGroupWrap.cs @@ -0,0 +1,370 @@ +#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 UnityEngineUIGridLayoutGroupWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.GridLayoutGroup); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 6, 6); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CalculateLayoutInputHorizontal", _m_CalculateLayoutInputHorizontal); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CalculateLayoutInputVertical", _m_CalculateLayoutInputVertical); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLayoutHorizontal", _m_SetLayoutHorizontal); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLayoutVertical", _m_SetLayoutVertical); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startCorner", _g_get_startCorner); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startAxis", _g_get_startAxis); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "cellSize", _g_get_cellSize); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "spacing", _g_get_spacing); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "constraint", _g_get_constraint); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "constraintCount", _g_get_constraintCount); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startCorner", _s_set_startCorner); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startAxis", _s_set_startAxis); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "cellSize", _s_set_cellSize); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "spacing", _s_set_spacing); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "constraint", _s_set_constraint); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "constraintCount", _s_set_constraintCount); + + + 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, "UnityEngine.UI.GridLayoutGroup does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalculateLayoutInputHorizontal(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.GridLayoutGroup gen_to_be_invoked = (UnityEngine.UI.GridLayoutGroup)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CalculateLayoutInputHorizontal( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalculateLayoutInputVertical(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.GridLayoutGroup gen_to_be_invoked = (UnityEngine.UI.GridLayoutGroup)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CalculateLayoutInputVertical( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLayoutHorizontal(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.GridLayoutGroup gen_to_be_invoked = (UnityEngine.UI.GridLayoutGroup)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetLayoutHorizontal( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLayoutVertical(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.GridLayoutGroup gen_to_be_invoked = (UnityEngine.UI.GridLayoutGroup)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetLayoutVertical( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startCorner(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.GridLayoutGroup gen_to_be_invoked = (UnityEngine.UI.GridLayoutGroup)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineUIGridLayoutGroupCorner(L, gen_to_be_invoked.startCorner); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startAxis(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.GridLayoutGroup gen_to_be_invoked = (UnityEngine.UI.GridLayoutGroup)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineUIGridLayoutGroupAxis(L, gen_to_be_invoked.startAxis); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cellSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.GridLayoutGroup gen_to_be_invoked = (UnityEngine.UI.GridLayoutGroup)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.cellSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_spacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.GridLayoutGroup gen_to_be_invoked = (UnityEngine.UI.GridLayoutGroup)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.spacing); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_constraint(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.GridLayoutGroup gen_to_be_invoked = (UnityEngine.UI.GridLayoutGroup)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineUIGridLayoutGroupConstraint(L, gen_to_be_invoked.constraint); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_constraintCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.GridLayoutGroup gen_to_be_invoked = (UnityEngine.UI.GridLayoutGroup)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.constraintCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startCorner(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.GridLayoutGroup gen_to_be_invoked = (UnityEngine.UI.GridLayoutGroup)translator.FastGetCSObj(L, 1); + UnityEngine.UI.GridLayoutGroup.Corner gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.startCorner = 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_startAxis(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.GridLayoutGroup gen_to_be_invoked = (UnityEngine.UI.GridLayoutGroup)translator.FastGetCSObj(L, 1); + UnityEngine.UI.GridLayoutGroup.Axis gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.startAxis = 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_cellSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.GridLayoutGroup gen_to_be_invoked = (UnityEngine.UI.GridLayoutGroup)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.cellSize = 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_spacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.GridLayoutGroup gen_to_be_invoked = (UnityEngine.UI.GridLayoutGroup)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.spacing = 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_constraint(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.GridLayoutGroup gen_to_be_invoked = (UnityEngine.UI.GridLayoutGroup)translator.FastGetCSObj(L, 1); + UnityEngine.UI.GridLayoutGroup.Constraint gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.constraint = 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_constraintCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.GridLayoutGroup gen_to_be_invoked = (UnityEngine.UI.GridLayoutGroup)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.constraintCount = 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/UnityEngine_UI_ImageWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_ImageWrap.cs new file mode 100644 index 000000000..5b39b7e10 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_ImageWrap.cs @@ -0,0 +1,989 @@ +#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; +using DG.Tweening; + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class UnityEngineUIImageWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.Image); + Utils.BeginObjectRegister(type, L, translator, 0, 12, 23, 13); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DisableSpriteOptimizations", _m_DisableSpriteOptimizations); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBeforeSerialize", _m_OnBeforeSerialize); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnAfterDeserialize", _m_OnAfterDeserialize); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetNativeSize", _m_SetNativeSize); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CalculateLayoutInputHorizontal", _m_CalculateLayoutInputHorizontal); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CalculateLayoutInputVertical", _m_CalculateLayoutInputVertical); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsRaycastLocationValid", _m_IsRaycastLocationValid); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOColor", _m_DOColor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOFade", _m_DOFade); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOFillAmount", _m_DOFillAmount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOGradientColor", _m_DOGradientColor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOBlendableColor", _m_DOBlendableColor); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sprite", _g_get_sprite); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "overrideSprite", _g_get_overrideSprite); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "type", _g_get_type); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preserveAspect", _g_get_preserveAspect); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fillCenter", _g_get_fillCenter); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fillMethod", _g_get_fillMethod); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fillAmount", _g_get_fillAmount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fillClockwise", _g_get_fillClockwise); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fillOrigin", _g_get_fillOrigin); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "alphaHitTestMinimumThreshold", _g_get_alphaHitTestMinimumThreshold); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "useSpriteMesh", _g_get_useSpriteMesh); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mainTexture", _g_get_mainTexture); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "hasBorder", _g_get_hasBorder); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "pixelsPerUnitMultiplier", _g_get_pixelsPerUnitMultiplier); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "pixelsPerUnit", _g_get_pixelsPerUnit); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "material", _g_get_material); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "minWidth", _g_get_minWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preferredWidth", _g_get_preferredWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "flexibleWidth", _g_get_flexibleWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "minHeight", _g_get_minHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preferredHeight", _g_get_preferredHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "flexibleHeight", _g_get_flexibleHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "layoutPriority", _g_get_layoutPriority); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sprite", _s_set_sprite); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "overrideSprite", _s_set_overrideSprite); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "type", _s_set_type); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "preserveAspect", _s_set_preserveAspect); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fillCenter", _s_set_fillCenter); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fillMethod", _s_set_fillMethod); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fillAmount", _s_set_fillAmount); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fillClockwise", _s_set_fillClockwise); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fillOrigin", _s_set_fillOrigin); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "alphaHitTestMinimumThreshold", _s_set_alphaHitTestMinimumThreshold); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "useSpriteMesh", _s_set_useSpriteMesh); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "pixelsPerUnitMultiplier", _s_set_pixelsPerUnitMultiplier); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "material", _s_set_material); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 1, 0); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "defaultETC1GraphicMaterial", _g_get_defaultETC1GraphicMaterial); + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "UnityEngine.UI.Image does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DisableSpriteOptimizations(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.DisableSpriteOptimizations( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnBeforeSerialize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.OnBeforeSerialize( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnAfterDeserialize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.OnAfterDeserialize( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetNativeSize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetNativeSize( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalculateLayoutInputHorizontal(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CalculateLayoutInputHorizontal( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalculateLayoutInputVertical(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CalculateLayoutInputVertical( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsRaycastLocationValid(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector2 _screenPoint;translator.Get(L, 2, out _screenPoint); + UnityEngine.Camera _eventCamera = (UnityEngine.Camera)translator.GetObject(L, 3, typeof(UnityEngine.Camera)); + + var gen_ret = gen_to_be_invoked.IsRaycastLocationValid( _screenPoint, _eventCamera ); + 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_DOColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Color _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOColor( _endValue, _duration ); + 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_DOFade(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + + + + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOFade( _endValue, _duration ); + 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_DOFillAmount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + + + + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOFillAmount( _endValue, _duration ); + 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_DOGradientColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Gradient _gradient = (UnityEngine.Gradient)translator.GetObject(L, 2, typeof(UnityEngine.Gradient)); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOGradientColor( _gradient, _duration ); + 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_DOBlendableColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Color _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOBlendableColor( _endValue, _duration ); + 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_sprite(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.sprite); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_overrideSprite(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.overrideSprite); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_type(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineUIImageType(L, gen_to_be_invoked.type); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preserveAspect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.preserveAspect); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fillCenter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.fillCenter); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fillMethod(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineUIImageFillMethod(L, gen_to_be_invoked.fillMethod); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fillAmount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.fillAmount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fillClockwise(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.fillClockwise); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fillOrigin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.fillOrigin); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_alphaHitTestMinimumThreshold(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.alphaHitTestMinimumThreshold); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_useSpriteMesh(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.useSpriteMesh); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_defaultETC1GraphicMaterial(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.UI.Image.defaultETC1GraphicMaterial); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mainTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.mainTexture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_hasBorder(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.hasBorder); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_pixelsPerUnitMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.pixelsPerUnitMultiplier); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_pixelsPerUnit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.pixelsPerUnit); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_material(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.material); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_minWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.minWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preferredWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.preferredWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_flexibleWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.flexibleWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_minHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.minHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preferredHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.preferredHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_flexibleHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.flexibleHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_layoutPriority(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.layoutPriority); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_sprite(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.sprite = (UnityEngine.Sprite)translator.GetObject(L, 2, typeof(UnityEngine.Sprite)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_overrideSprite(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.overrideSprite = (UnityEngine.Sprite)translator.GetObject(L, 2, typeof(UnityEngine.Sprite)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_type(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + UnityEngine.UI.Image.Type gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.type = 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_preserveAspect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.preserveAspect = 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_fillCenter(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.fillCenter = 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_fillMethod(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + UnityEngine.UI.Image.FillMethod gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.fillMethod = 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_fillAmount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.fillAmount = (float)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_fillClockwise(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.fillClockwise = 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_fillOrigin(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.fillOrigin = 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_alphaHitTestMinimumThreshold(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.alphaHitTestMinimumThreshold = (float)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_useSpriteMesh(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.useSpriteMesh = 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_pixelsPerUnitMultiplier(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.pixelsPerUnitMultiplier = (float)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_material(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Image gen_to_be_invoked = (UnityEngine.UI.Image)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.material = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_UI_InputFieldWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_InputFieldWrap.cs new file mode 100644 index 000000000..970fab059 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_InputFieldWrap.cs @@ -0,0 +1,1616 @@ +#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 UnityEngineUIInputFieldWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.InputField); + Utils.BeginObjectRegister(type, L, translator, 0, 21, 36, 25); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTextWithoutNotify", _m_SetTextWithoutNotify); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "MoveTextEnd", _m_MoveTextEnd); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "MoveTextStart", _m_MoveTextStart); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBeginDrag", _m_OnBeginDrag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnDrag", _m_OnDrag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnEndDrag", _m_OnEndDrag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerDown", _m_OnPointerDown); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ProcessEvent", _m_ProcessEvent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnUpdateSelected", _m_OnUpdateSelected); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ForceLabelUpdate", _m_ForceLabelUpdate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Rebuild", _m_Rebuild); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LayoutComplete", _m_LayoutComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GraphicUpdateComplete", _m_GraphicUpdateComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ActivateInputField", _m_ActivateInputField); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnSelect", _m_OnSelect); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerClick", _m_OnPointerClick); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DeactivateInputField", _m_DeactivateInputField); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnDeselect", _m_OnDeselect); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnSubmit", _m_OnSubmit); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CalculateLayoutInputHorizontal", _m_CalculateLayoutInputHorizontal); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CalculateLayoutInputVertical", _m_CalculateLayoutInputVertical); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "shouldHideMobileInput", _g_get_shouldHideMobileInput); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "shouldActivateOnSelect", _g_get_shouldActivateOnSelect); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "text", _g_get_text); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isFocused", _g_get_isFocused); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "caretBlinkRate", _g_get_caretBlinkRate); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "caretWidth", _g_get_caretWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "textComponent", _g_get_textComponent); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "placeholder", _g_get_placeholder); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "caretColor", _g_get_caretColor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "customCaretColor", _g_get_customCaretColor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "selectionColor", _g_get_selectionColor); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onEndEdit", _g_get_onEndEdit); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onSubmit", _g_get_onSubmit); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onValueChanged", _g_get_onValueChanged); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onValidateInput", _g_get_onValidateInput); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "characterLimit", _g_get_characterLimit); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "contentType", _g_get_contentType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lineType", _g_get_lineType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "inputType", _g_get_inputType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "touchScreenKeyboard", _g_get_touchScreenKeyboard); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "keyboardType", _g_get_keyboardType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "characterValidation", _g_get_characterValidation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "readOnly", _g_get_readOnly); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "multiLine", _g_get_multiLine); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "asteriskChar", _g_get_asteriskChar); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "wasCanceled", _g_get_wasCanceled); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "caretPosition", _g_get_caretPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "selectionAnchorPosition", _g_get_selectionAnchorPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "selectionFocusPosition", _g_get_selectionFocusPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "minWidth", _g_get_minWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preferredWidth", _g_get_preferredWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "flexibleWidth", _g_get_flexibleWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "minHeight", _g_get_minHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preferredHeight", _g_get_preferredHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "flexibleHeight", _g_get_flexibleHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "layoutPriority", _g_get_layoutPriority); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "shouldHideMobileInput", _s_set_shouldHideMobileInput); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "shouldActivateOnSelect", _s_set_shouldActivateOnSelect); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "text", _s_set_text); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "caretBlinkRate", _s_set_caretBlinkRate); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "caretWidth", _s_set_caretWidth); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "textComponent", _s_set_textComponent); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "placeholder", _s_set_placeholder); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "caretColor", _s_set_caretColor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "customCaretColor", _s_set_customCaretColor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "selectionColor", _s_set_selectionColor); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onEndEdit", _s_set_onEndEdit); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onSubmit", _s_set_onSubmit); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onValueChanged", _s_set_onValueChanged); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onValidateInput", _s_set_onValidateInput); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "characterLimit", _s_set_characterLimit); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "contentType", _s_set_contentType); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "lineType", _s_set_lineType); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "inputType", _s_set_inputType); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "keyboardType", _s_set_keyboardType); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "characterValidation", _s_set_characterValidation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "readOnly", _s_set_readOnly); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "asteriskChar", _s_set_asteriskChar); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "caretPosition", _s_set_caretPosition); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "selectionAnchorPosition", _s_set_selectionAnchorPosition); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "selectionFocusPosition", _s_set_selectionFocusPosition); + + + 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, "UnityEngine.UI.InputField does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetTextWithoutNotify(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + + + + { + string _input = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SetTextWithoutNotify( _input ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_MoveTextEnd(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + + + + { + bool _shift = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.MoveTextEnd( _shift ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_MoveTextStart(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + + + + { + bool _shift = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.MoveTextStart( _shift ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnBeginDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnBeginDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnEndDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnEndDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerDown(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerDown( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ProcessEvent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Event _e = (UnityEngine.Event)translator.GetObject(L, 2, typeof(UnityEngine.Event)); + + gen_to_be_invoked.ProcessEvent( _e ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnUpdateSelected(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.BaseEventData _eventData = (UnityEngine.EventSystems.BaseEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.BaseEventData)); + + gen_to_be_invoked.OnUpdateSelected( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ForceLabelUpdate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ForceLabelUpdate( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Rebuild(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.UI.CanvasUpdate _update;translator.Get(L, 2, out _update); + + gen_to_be_invoked.Rebuild( _update ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LayoutComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.LayoutComplete( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GraphicUpdateComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.GraphicUpdateComplete( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ActivateInputField(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.ActivateInputField( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnSelect(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.BaseEventData _eventData = (UnityEngine.EventSystems.BaseEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.BaseEventData)); + + gen_to_be_invoked.OnSelect( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerClick(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerClick( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DeactivateInputField(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.DeactivateInputField( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnDeselect(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.BaseEventData _eventData = (UnityEngine.EventSystems.BaseEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.BaseEventData)); + + gen_to_be_invoked.OnDeselect( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnSubmit(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.BaseEventData _eventData = (UnityEngine.EventSystems.BaseEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.BaseEventData)); + + gen_to_be_invoked.OnSubmit( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalculateLayoutInputHorizontal(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CalculateLayoutInputHorizontal( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalculateLayoutInputVertical(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CalculateLayoutInputVertical( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_shouldHideMobileInput(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.shouldHideMobileInput); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_shouldActivateOnSelect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.shouldActivateOnSelect); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_text(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.text); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isFocused(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isFocused); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_caretBlinkRate(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.caretBlinkRate); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_caretWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.caretWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_textComponent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.textComponent); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_placeholder(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.placeholder); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_caretColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineColor(L, gen_to_be_invoked.caretColor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_customCaretColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.customCaretColor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_selectionColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineColor(L, gen_to_be_invoked.selectionColor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onEndEdit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onEndEdit); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onSubmit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onSubmit); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onValueChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onValueChanged); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onValidateInput(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onValidateInput); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_characterLimit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.characterLimit); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_contentType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineUIInputFieldContentType(L, gen_to_be_invoked.contentType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lineType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineUIInputFieldLineType(L, gen_to_be_invoked.lineType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_inputType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineUIInputFieldInputType(L, gen_to_be_invoked.inputType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_touchScreenKeyboard(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.touchScreenKeyboard); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_keyboardType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.keyboardType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_characterValidation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineUIInputFieldCharacterValidation(L, gen_to_be_invoked.characterValidation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_readOnly(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.readOnly); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_multiLine(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.multiLine); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_asteriskChar(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.asteriskChar); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_wasCanceled(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.wasCanceled); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_caretPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.caretPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_selectionAnchorPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.selectionAnchorPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_selectionFocusPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.selectionFocusPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_minWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.minWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preferredWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.preferredWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_flexibleWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.flexibleWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_minHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.minHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preferredHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.preferredHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_flexibleHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.flexibleHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_layoutPriority(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.layoutPriority); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_shouldHideMobileInput(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.shouldHideMobileInput = 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_shouldActivateOnSelect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.shouldActivateOnSelect = 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_text(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.text = 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_caretBlinkRate(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.caretBlinkRate = (float)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_caretWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.caretWidth = 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_textComponent(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.textComponent = (UnityEngine.UI.Text)translator.GetObject(L, 2, typeof(UnityEngine.UI.Text)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_placeholder(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.placeholder = (UnityEngine.UI.Graphic)translator.GetObject(L, 2, typeof(UnityEngine.UI.Graphic)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_caretColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + UnityEngine.Color gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.caretColor = 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_customCaretColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.customCaretColor = 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_selectionColor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + UnityEngine.Color gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.selectionColor = 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_onEndEdit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onEndEdit = (UnityEngine.UI.InputField.EndEditEvent)translator.GetObject(L, 2, typeof(UnityEngine.UI.InputField.EndEditEvent)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_onSubmit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onSubmit = (UnityEngine.UI.InputField.SubmitEvent)translator.GetObject(L, 2, typeof(UnityEngine.UI.InputField.SubmitEvent)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_onValueChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onValueChanged = (UnityEngine.UI.InputField.OnChangeEvent)translator.GetObject(L, 2, typeof(UnityEngine.UI.InputField.OnChangeEvent)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_onValidateInput(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onValidateInput = translator.GetDelegate(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_characterLimit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.characterLimit = 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_contentType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + UnityEngine.UI.InputField.ContentType gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.contentType = 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_lineType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + UnityEngine.UI.InputField.LineType gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.lineType = 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_inputType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + UnityEngine.UI.InputField.InputType gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.inputType = 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_keyboardType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + UnityEngine.TouchScreenKeyboardType gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.keyboardType = 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_characterValidation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + UnityEngine.UI.InputField.CharacterValidation gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.characterValidation = 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_readOnly(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.readOnly = 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_asteriskChar(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.asteriskChar = (char)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_caretPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.caretPosition = 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_selectionAnchorPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.selectionAnchorPosition = 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_selectionFocusPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.InputField gen_to_be_invoked = (UnityEngine.UI.InputField)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.selectionFocusPosition = 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/UnityEngine_UI_InputField_EndEditEventWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_InputField_EndEditEventWrap.cs new file mode 100644 index 000000000..f8ecfae69 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_InputField_EndEditEventWrap.cs @@ -0,0 +1,84 @@ +#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 UnityEngineUIInputFieldEndEditEventWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.InputField.EndEditEvent); + 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) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new UnityEngine.UI.InputField.EndEditEvent(); + 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 UnityEngine.UI.InputField.EndEditEvent constructor!"); + + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_UI_InputField_OnChangeEventWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_InputField_OnChangeEventWrap.cs new file mode 100644 index 000000000..d83c55391 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_InputField_OnChangeEventWrap.cs @@ -0,0 +1,84 @@ +#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 UnityEngineUIInputFieldOnChangeEventWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.InputField.OnChangeEvent); + 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) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new UnityEngine.UI.InputField.OnChangeEvent(); + 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 UnityEngine.UI.InputField.OnChangeEvent constructor!"); + + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_UI_InputField_SubmitEventWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_InputField_SubmitEventWrap.cs new file mode 100644 index 000000000..fd8ac54e1 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_InputField_SubmitEventWrap.cs @@ -0,0 +1,84 @@ +#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 UnityEngineUIInputFieldSubmitEventWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.InputField.SubmitEvent); + 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) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new UnityEngine.UI.InputField.SubmitEvent(); + 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 UnityEngine.UI.InputField.SubmitEvent constructor!"); + + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_UI_LayoutElementWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_LayoutElementWrap.cs new file mode 100644 index 000000000..8b883e7b8 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_LayoutElementWrap.cs @@ -0,0 +1,515 @@ +#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; +using DG.Tweening; + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class UnityEngineUILayoutElementWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.LayoutElement); + Utils.BeginObjectRegister(type, L, translator, 0, 5, 8, 8); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CalculateLayoutInputHorizontal", _m_CalculateLayoutInputHorizontal); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CalculateLayoutInputVertical", _m_CalculateLayoutInputVertical); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOFlexibleSize", _m_DOFlexibleSize); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOMinSize", _m_DOMinSize); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOPreferredSize", _m_DOPreferredSize); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "ignoreLayout", _g_get_ignoreLayout); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "minWidth", _g_get_minWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "minHeight", _g_get_minHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preferredWidth", _g_get_preferredWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preferredHeight", _g_get_preferredHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "flexibleWidth", _g_get_flexibleWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "flexibleHeight", _g_get_flexibleHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "layoutPriority", _g_get_layoutPriority); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "ignoreLayout", _s_set_ignoreLayout); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "minWidth", _s_set_minWidth); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "minHeight", _s_set_minHeight); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "preferredWidth", _s_set_preferredWidth); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "preferredHeight", _s_set_preferredHeight); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "flexibleWidth", _s_set_flexibleWidth); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "flexibleHeight", _s_set_flexibleHeight); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "layoutPriority", _s_set_layoutPriority); + + + 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, "UnityEngine.UI.LayoutElement does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalculateLayoutInputHorizontal(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.LayoutElement gen_to_be_invoked = (UnityEngine.UI.LayoutElement)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CalculateLayoutInputHorizontal( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalculateLayoutInputVertical(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.LayoutElement gen_to_be_invoked = (UnityEngine.UI.LayoutElement)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CalculateLayoutInputVertical( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOFlexibleSize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.LayoutElement gen_to_be_invoked = (UnityEngine.UI.LayoutElement)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector2 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapping = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.DOFlexibleSize( _endValue, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector2 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOFlexibleSize( _endValue, _duration ); + 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 UnityEngine.UI.LayoutElement.DOFlexibleSize!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOMinSize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.LayoutElement gen_to_be_invoked = (UnityEngine.UI.LayoutElement)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector2 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapping = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.DOMinSize( _endValue, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector2 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOMinSize( _endValue, _duration ); + 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 UnityEngine.UI.LayoutElement.DOMinSize!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOPreferredSize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.LayoutElement gen_to_be_invoked = (UnityEngine.UI.LayoutElement)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector2 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapping = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.DOPreferredSize( _endValue, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector2 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOPreferredSize( _endValue, _duration ); + 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 UnityEngine.UI.LayoutElement.DOPreferredSize!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_ignoreLayout(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.LayoutElement gen_to_be_invoked = (UnityEngine.UI.LayoutElement)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.ignoreLayout); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_minWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.LayoutElement gen_to_be_invoked = (UnityEngine.UI.LayoutElement)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.minWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_minHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.LayoutElement gen_to_be_invoked = (UnityEngine.UI.LayoutElement)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.minHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preferredWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.LayoutElement gen_to_be_invoked = (UnityEngine.UI.LayoutElement)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.preferredWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preferredHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.LayoutElement gen_to_be_invoked = (UnityEngine.UI.LayoutElement)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.preferredHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_flexibleWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.LayoutElement gen_to_be_invoked = (UnityEngine.UI.LayoutElement)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.flexibleWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_flexibleHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.LayoutElement gen_to_be_invoked = (UnityEngine.UI.LayoutElement)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.flexibleHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_layoutPriority(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.LayoutElement gen_to_be_invoked = (UnityEngine.UI.LayoutElement)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.layoutPriority); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_ignoreLayout(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.LayoutElement gen_to_be_invoked = (UnityEngine.UI.LayoutElement)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.ignoreLayout = 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_minWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.LayoutElement gen_to_be_invoked = (UnityEngine.UI.LayoutElement)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.minWidth = (float)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_minHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.LayoutElement gen_to_be_invoked = (UnityEngine.UI.LayoutElement)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.minHeight = (float)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_preferredWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.LayoutElement gen_to_be_invoked = (UnityEngine.UI.LayoutElement)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.preferredWidth = (float)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_preferredHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.LayoutElement gen_to_be_invoked = (UnityEngine.UI.LayoutElement)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.preferredHeight = (float)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_flexibleWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.LayoutElement gen_to_be_invoked = (UnityEngine.UI.LayoutElement)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.flexibleWidth = (float)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_flexibleHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.LayoutElement gen_to_be_invoked = (UnityEngine.UI.LayoutElement)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.flexibleHeight = (float)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_layoutPriority(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.LayoutElement gen_to_be_invoked = (UnityEngine.UI.LayoutElement)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.layoutPriority = 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/UnityEngine_UI_LayoutGroupWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_LayoutGroupWrap.cs new file mode 100644 index 000000000..7c243cf4e --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_LayoutGroupWrap.cs @@ -0,0 +1,347 @@ +#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 UnityEngineUILayoutGroupWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.LayoutGroup); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 9, 2); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CalculateLayoutInputHorizontal", _m_CalculateLayoutInputHorizontal); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CalculateLayoutInputVertical", _m_CalculateLayoutInputVertical); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLayoutHorizontal", _m_SetLayoutHorizontal); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLayoutVertical", _m_SetLayoutVertical); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "padding", _g_get_padding); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "childAlignment", _g_get_childAlignment); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "minWidth", _g_get_minWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preferredWidth", _g_get_preferredWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "flexibleWidth", _g_get_flexibleWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "minHeight", _g_get_minHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preferredHeight", _g_get_preferredHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "flexibleHeight", _g_get_flexibleHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "layoutPriority", _g_get_layoutPriority); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "padding", _s_set_padding); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "childAlignment", _s_set_childAlignment); + + + 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, "UnityEngine.UI.LayoutGroup does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalculateLayoutInputHorizontal(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.LayoutGroup gen_to_be_invoked = (UnityEngine.UI.LayoutGroup)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CalculateLayoutInputHorizontal( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalculateLayoutInputVertical(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.LayoutGroup gen_to_be_invoked = (UnityEngine.UI.LayoutGroup)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CalculateLayoutInputVertical( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLayoutHorizontal(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.LayoutGroup gen_to_be_invoked = (UnityEngine.UI.LayoutGroup)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetLayoutHorizontal( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLayoutVertical(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.LayoutGroup gen_to_be_invoked = (UnityEngine.UI.LayoutGroup)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetLayoutVertical( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_padding(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.LayoutGroup gen_to_be_invoked = (UnityEngine.UI.LayoutGroup)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.padding); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_childAlignment(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.LayoutGroup gen_to_be_invoked = (UnityEngine.UI.LayoutGroup)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineTextAnchor(L, gen_to_be_invoked.childAlignment); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_minWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.LayoutGroup gen_to_be_invoked = (UnityEngine.UI.LayoutGroup)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.minWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preferredWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.LayoutGroup gen_to_be_invoked = (UnityEngine.UI.LayoutGroup)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.preferredWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_flexibleWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.LayoutGroup gen_to_be_invoked = (UnityEngine.UI.LayoutGroup)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.flexibleWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_minHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.LayoutGroup gen_to_be_invoked = (UnityEngine.UI.LayoutGroup)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.minHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preferredHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.LayoutGroup gen_to_be_invoked = (UnityEngine.UI.LayoutGroup)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.preferredHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_flexibleHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.LayoutGroup gen_to_be_invoked = (UnityEngine.UI.LayoutGroup)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.flexibleHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_layoutPriority(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.LayoutGroup gen_to_be_invoked = (UnityEngine.UI.LayoutGroup)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.layoutPriority); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_padding(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.LayoutGroup gen_to_be_invoked = (UnityEngine.UI.LayoutGroup)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.padding = (UnityEngine.RectOffset)translator.GetObject(L, 2, typeof(UnityEngine.RectOffset)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_childAlignment(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.LayoutGroup gen_to_be_invoked = (UnityEngine.UI.LayoutGroup)translator.FastGetCSObj(L, 1); + UnityEngine.TextAnchor gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.childAlignment = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_UI_MaskUtilitiesWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_MaskUtilitiesWrap.cs new file mode 100644 index 000000000..0bcdaa374 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_MaskUtilitiesWrap.cs @@ -0,0 +1,280 @@ +#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 UnityEngineUIMaskUtilitiesWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.MaskUtilities); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 8, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Notify2DMaskStateChanged", _m_Notify2DMaskStateChanged_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "NotifyStencilStateChanged", _m_NotifyStencilStateChanged_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "FindRootSortOverrideCanvas", _m_FindRootSortOverrideCanvas_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetStencilDepth", _m_GetStencilDepth_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "IsDescendantOrSelf", _m_IsDescendantOrSelf_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetRectMaskForClippable", _m_GetRectMaskForClippable_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetRectMasksForClip", _m_GetRectMasksForClip_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 UnityEngine.UI.MaskUtilities(); + 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 UnityEngine.UI.MaskUtilities constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Notify2DMaskStateChanged_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Component _mask = (UnityEngine.Component)translator.GetObject(L, 1, typeof(UnityEngine.Component)); + + UnityEngine.UI.MaskUtilities.Notify2DMaskStateChanged( _mask ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_NotifyStencilStateChanged_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Component _mask = (UnityEngine.Component)translator.GetObject(L, 1, typeof(UnityEngine.Component)); + + UnityEngine.UI.MaskUtilities.NotifyStencilStateChanged( _mask ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FindRootSortOverrideCanvas_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Transform _start = (UnityEngine.Transform)translator.GetObject(L, 1, typeof(UnityEngine.Transform)); + + var gen_ret = UnityEngine.UI.MaskUtilities.FindRootSortOverrideCanvas( _start ); + 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_GetStencilDepth_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Transform _transform = (UnityEngine.Transform)translator.GetObject(L, 1, typeof(UnityEngine.Transform)); + UnityEngine.Transform _stopAfter = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + + var gen_ret = UnityEngine.UI.MaskUtilities.GetStencilDepth( _transform, _stopAfter ); + 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_IsDescendantOrSelf_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Transform _father = (UnityEngine.Transform)translator.GetObject(L, 1, typeof(UnityEngine.Transform)); + UnityEngine.Transform _child = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform)); + + var gen_ret = UnityEngine.UI.MaskUtilities.IsDescendantOrSelf( _father, _child ); + 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_GetRectMaskForClippable_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.UI.IClippable _clippable = (UnityEngine.UI.IClippable)translator.GetObject(L, 1, typeof(UnityEngine.UI.IClippable)); + + var gen_ret = UnityEngine.UI.MaskUtilities.GetRectMaskForClippable( _clippable ); + 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_GetRectMasksForClip_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.UI.RectMask2D _clipper = (UnityEngine.UI.RectMask2D)translator.GetObject(L, 1, typeof(UnityEngine.UI.RectMask2D)); + System.Collections.Generic.List _masks = (System.Collections.Generic.List)translator.GetObject(L, 2, typeof(System.Collections.Generic.List)); + + UnityEngine.UI.MaskUtilities.GetRectMasksForClip( _clipper, _masks ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_UI_MaskWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_MaskWrap.cs new file mode 100644 index 000000000..e80359731 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_MaskWrap.cs @@ -0,0 +1,218 @@ +#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 UnityEngineUIMaskWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.Mask); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 3, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "MaskEnabled", _m_MaskEnabled); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsRaycastLocationValid", _m_IsRaycastLocationValid); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetModifiedMaterial", _m_GetModifiedMaterial); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rectTransform", _g_get_rectTransform); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "showMaskGraphic", _g_get_showMaskGraphic); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "graphic", _g_get_graphic); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "showMaskGraphic", _s_set_showMaskGraphic); + + + 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, "UnityEngine.UI.Mask does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_MaskEnabled(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Mask gen_to_be_invoked = (UnityEngine.UI.Mask)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.MaskEnabled( ); + 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_IsRaycastLocationValid(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Mask gen_to_be_invoked = (UnityEngine.UI.Mask)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector2 _sp;translator.Get(L, 2, out _sp); + UnityEngine.Camera _eventCamera = (UnityEngine.Camera)translator.GetObject(L, 3, typeof(UnityEngine.Camera)); + + var gen_ret = gen_to_be_invoked.IsRaycastLocationValid( _sp, _eventCamera ); + 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_GetModifiedMaterial(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Mask gen_to_be_invoked = (UnityEngine.UI.Mask)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Material _baseMaterial = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + var gen_ret = gen_to_be_invoked.GetModifiedMaterial( _baseMaterial ); + 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_rectTransform(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Mask gen_to_be_invoked = (UnityEngine.UI.Mask)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.rectTransform); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_showMaskGraphic(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Mask gen_to_be_invoked = (UnityEngine.UI.Mask)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.showMaskGraphic); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_graphic(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Mask gen_to_be_invoked = (UnityEngine.UI.Mask)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.graphic); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_showMaskGraphic(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Mask gen_to_be_invoked = (UnityEngine.UI.Mask)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.showMaskGraphic = LuaAPI.lua_toboolean(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_UI_MaskableGraphicWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_MaskableGraphicWrap.cs new file mode 100644 index 000000000..edd933932 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_MaskableGraphicWrap.cs @@ -0,0 +1,335 @@ +#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 UnityEngineUIMaskableGraphicWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.MaskableGraphic); + Utils.BeginObjectRegister(type, L, translator, 0, 6, 3, 3); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetModifiedMaterial", _m_GetModifiedMaterial); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Cull", _m_Cull); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetClipRect", _m_SetClipRect); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetClipSoftness", _m_SetClipSoftness); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RecalculateClipping", _m_RecalculateClipping); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RecalculateMasking", _m_RecalculateMasking); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onCullStateChanged", _g_get_onCullStateChanged); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "maskable", _g_get_maskable); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isMaskingGraphic", _g_get_isMaskingGraphic); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onCullStateChanged", _s_set_onCullStateChanged); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "maskable", _s_set_maskable); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "isMaskingGraphic", _s_set_isMaskingGraphic); + + + 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, "UnityEngine.UI.MaskableGraphic does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetModifiedMaterial(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.MaskableGraphic gen_to_be_invoked = (UnityEngine.UI.MaskableGraphic)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Material _baseMaterial = (UnityEngine.Material)translator.GetObject(L, 2, typeof(UnityEngine.Material)); + + var gen_ret = gen_to_be_invoked.GetModifiedMaterial( _baseMaterial ); + 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_Cull(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.MaskableGraphic gen_to_be_invoked = (UnityEngine.UI.MaskableGraphic)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Rect _clipRect;translator.Get(L, 2, out _clipRect); + bool _validRect = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.Cull( _clipRect, _validRect ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetClipRect(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.MaskableGraphic gen_to_be_invoked = (UnityEngine.UI.MaskableGraphic)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Rect _clipRect;translator.Get(L, 2, out _clipRect); + bool _validRect = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.SetClipRect( _clipRect, _validRect ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetClipSoftness(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.MaskableGraphic gen_to_be_invoked = (UnityEngine.UI.MaskableGraphic)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector2 _clipSoftness;translator.Get(L, 2, out _clipSoftness); + + gen_to_be_invoked.SetClipSoftness( _clipSoftness ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RecalculateClipping(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.MaskableGraphic gen_to_be_invoked = (UnityEngine.UI.MaskableGraphic)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RecalculateClipping( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RecalculateMasking(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.MaskableGraphic gen_to_be_invoked = (UnityEngine.UI.MaskableGraphic)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.RecalculateMasking( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onCullStateChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.MaskableGraphic gen_to_be_invoked = (UnityEngine.UI.MaskableGraphic)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onCullStateChanged); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maskable(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.MaskableGraphic gen_to_be_invoked = (UnityEngine.UI.MaskableGraphic)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.maskable); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isMaskingGraphic(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.MaskableGraphic gen_to_be_invoked = (UnityEngine.UI.MaskableGraphic)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isMaskingGraphic); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_onCullStateChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.MaskableGraphic gen_to_be_invoked = (UnityEngine.UI.MaskableGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onCullStateChanged = (UnityEngine.UI.MaskableGraphic.CullStateChangedEvent)translator.GetObject(L, 2, typeof(UnityEngine.UI.MaskableGraphic.CullStateChangedEvent)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_maskable(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.MaskableGraphic gen_to_be_invoked = (UnityEngine.UI.MaskableGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.maskable = 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_isMaskingGraphic(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.MaskableGraphic gen_to_be_invoked = (UnityEngine.UI.MaskableGraphic)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.isMaskingGraphic = LuaAPI.lua_toboolean(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_UI_MaskableGraphic_CullStateChangedEventWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_MaskableGraphic_CullStateChangedEventWrap.cs new file mode 100644 index 000000000..c6580b142 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_MaskableGraphic_CullStateChangedEventWrap.cs @@ -0,0 +1,84 @@ +#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 UnityEngineUIMaskableGraphicCullStateChangedEventWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.MaskableGraphic.CullStateChangedEvent); + 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) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new UnityEngine.UI.MaskableGraphic.CullStateChangedEvent(); + 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 UnityEngine.UI.MaskableGraphic.CullStateChangedEvent constructor!"); + + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_UI_RawImageWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_RawImageWrap.cs new file mode 100644 index 000000000..f831138dd --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_RawImageWrap.cs @@ -0,0 +1,173 @@ +#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 UnityEngineUIRawImageWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.RawImage); + Utils.BeginObjectRegister(type, L, translator, 0, 1, 3, 2); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetNativeSize", _m_SetNativeSize); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mainTexture", _g_get_mainTexture); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "texture", _g_get_texture); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "uvRect", _g_get_uvRect); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "texture", _s_set_texture); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "uvRect", _s_set_uvRect); + + + 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, "UnityEngine.UI.RawImage does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetNativeSize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.RawImage gen_to_be_invoked = (UnityEngine.UI.RawImage)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetNativeSize( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mainTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.RawImage gen_to_be_invoked = (UnityEngine.UI.RawImage)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.mainTexture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_texture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.RawImage gen_to_be_invoked = (UnityEngine.UI.RawImage)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.texture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_uvRect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.RawImage gen_to_be_invoked = (UnityEngine.UI.RawImage)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.uvRect); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_texture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.RawImage gen_to_be_invoked = (UnityEngine.UI.RawImage)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.texture = (UnityEngine.Texture)translator.GetObject(L, 2, typeof(UnityEngine.Texture)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_uvRect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.RawImage gen_to_be_invoked = (UnityEngine.UI.RawImage)translator.FastGetCSObj(L, 1); + UnityEngine.Rect gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.uvRect = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_UI_RectMask2DWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_RectMask2DWrap.cs new file mode 100644 index 000000000..4a436a74a --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_RectMask2DWrap.cs @@ -0,0 +1,306 @@ +#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 UnityEngineUIRectMask2DWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.RectMask2D); + Utils.BeginObjectRegister(type, L, translator, 0, 5, 4, 2); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsRaycastLocationValid", _m_IsRaycastLocationValid); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "PerformClipping", _m_PerformClipping); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateClipSoftness", _m_UpdateClipSoftness); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddClippable", _m_AddClippable); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveClippable", _m_RemoveClippable); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "padding", _g_get_padding); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "softness", _g_get_softness); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "canvasRect", _g_get_canvasRect); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "rectTransform", _g_get_rectTransform); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "padding", _s_set_padding); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "softness", _s_set_softness); + + + 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, "UnityEngine.UI.RectMask2D does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsRaycastLocationValid(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.RectMask2D gen_to_be_invoked = (UnityEngine.UI.RectMask2D)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector2 _sp;translator.Get(L, 2, out _sp); + UnityEngine.Camera _eventCamera = (UnityEngine.Camera)translator.GetObject(L, 3, typeof(UnityEngine.Camera)); + + var gen_ret = gen_to_be_invoked.IsRaycastLocationValid( _sp, _eventCamera ); + 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_PerformClipping(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.RectMask2D gen_to_be_invoked = (UnityEngine.UI.RectMask2D)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.PerformClipping( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UpdateClipSoftness(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.RectMask2D gen_to_be_invoked = (UnityEngine.UI.RectMask2D)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.UpdateClipSoftness( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AddClippable(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.RectMask2D gen_to_be_invoked = (UnityEngine.UI.RectMask2D)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.UI.IClippable _clippable = (UnityEngine.UI.IClippable)translator.GetObject(L, 2, typeof(UnityEngine.UI.IClippable)); + + gen_to_be_invoked.AddClippable( _clippable ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RemoveClippable(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.RectMask2D gen_to_be_invoked = (UnityEngine.UI.RectMask2D)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.UI.IClippable _clippable = (UnityEngine.UI.IClippable)translator.GetObject(L, 2, typeof(UnityEngine.UI.IClippable)); + + gen_to_be_invoked.RemoveClippable( _clippable ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_padding(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.RectMask2D gen_to_be_invoked = (UnityEngine.UI.RectMask2D)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector4(L, gen_to_be_invoked.padding); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_softness(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.RectMask2D gen_to_be_invoked = (UnityEngine.UI.RectMask2D)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.softness); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_canvasRect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.RectMask2D gen_to_be_invoked = (UnityEngine.UI.RectMask2D)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.canvasRect); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_rectTransform(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.RectMask2D gen_to_be_invoked = (UnityEngine.UI.RectMask2D)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.rectTransform); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_padding(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.RectMask2D gen_to_be_invoked = (UnityEngine.UI.RectMask2D)translator.FastGetCSObj(L, 1); + UnityEngine.Vector4 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.padding = 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_softness(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.RectMask2D gen_to_be_invoked = (UnityEngine.UI.RectMask2D)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2Int gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.softness = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_UI_ScrollRectWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_ScrollRectWrap.cs new file mode 100644 index 000000000..d65004d02 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_ScrollRectWrap.cs @@ -0,0 +1,1340 @@ +#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; +using DG.Tweening; + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class UnityEngineUIScrollRectWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.ScrollRect); + Utils.BeginObjectRegister(type, L, translator, 0, 17, 27, 20); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Rebuild", _m_Rebuild); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LayoutComplete", _m_LayoutComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GraphicUpdateComplete", _m_GraphicUpdateComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsActive", _m_IsActive); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "StopMovement", _m_StopMovement); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnScroll", _m_OnScroll); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnInitializePotentialDrag", _m_OnInitializePotentialDrag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBeginDrag", _m_OnBeginDrag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnEndDrag", _m_OnEndDrag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnDrag", _m_OnDrag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CalculateLayoutInputHorizontal", _m_CalculateLayoutInputHorizontal); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CalculateLayoutInputVertical", _m_CalculateLayoutInputVertical); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLayoutHorizontal", _m_SetLayoutHorizontal); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLayoutVertical", _m_SetLayoutVertical); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DONormalizedPos", _m_DONormalizedPos); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOHorizontalNormalizedPos", _m_DOHorizontalNormalizedPos); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOVerticalNormalizedPos", _m_DOVerticalNormalizedPos); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "content", _g_get_content); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "horizontal", _g_get_horizontal); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "vertical", _g_get_vertical); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "movementType", _g_get_movementType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "elasticity", _g_get_elasticity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "inertia", _g_get_inertia); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "decelerationRate", _g_get_decelerationRate); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "scrollSensitivity", _g_get_scrollSensitivity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "viewport", _g_get_viewport); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "horizontalScrollbar", _g_get_horizontalScrollbar); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "verticalScrollbar", _g_get_verticalScrollbar); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "horizontalScrollbarVisibility", _g_get_horizontalScrollbarVisibility); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "verticalScrollbarVisibility", _g_get_verticalScrollbarVisibility); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "horizontalScrollbarSpacing", _g_get_horizontalScrollbarSpacing); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "verticalScrollbarSpacing", _g_get_verticalScrollbarSpacing); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onValueChanged", _g_get_onValueChanged); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "velocity", _g_get_velocity); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "normalizedPosition", _g_get_normalizedPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "horizontalNormalizedPosition", _g_get_horizontalNormalizedPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "verticalNormalizedPosition", _g_get_verticalNormalizedPosition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "minWidth", _g_get_minWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preferredWidth", _g_get_preferredWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "flexibleWidth", _g_get_flexibleWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "minHeight", _g_get_minHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preferredHeight", _g_get_preferredHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "flexibleHeight", _g_get_flexibleHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "layoutPriority", _g_get_layoutPriority); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "content", _s_set_content); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "horizontal", _s_set_horizontal); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "vertical", _s_set_vertical); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "movementType", _s_set_movementType); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "elasticity", _s_set_elasticity); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "inertia", _s_set_inertia); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "decelerationRate", _s_set_decelerationRate); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "scrollSensitivity", _s_set_scrollSensitivity); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "viewport", _s_set_viewport); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "horizontalScrollbar", _s_set_horizontalScrollbar); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "verticalScrollbar", _s_set_verticalScrollbar); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "horizontalScrollbarVisibility", _s_set_horizontalScrollbarVisibility); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "verticalScrollbarVisibility", _s_set_verticalScrollbarVisibility); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "horizontalScrollbarSpacing", _s_set_horizontalScrollbarSpacing); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "verticalScrollbarSpacing", _s_set_verticalScrollbarSpacing); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onValueChanged", _s_set_onValueChanged); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "velocity", _s_set_velocity); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "normalizedPosition", _s_set_normalizedPosition); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "horizontalNormalizedPosition", _s_set_horizontalNormalizedPosition); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "verticalNormalizedPosition", _s_set_verticalNormalizedPosition); + + + 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, "UnityEngine.UI.ScrollRect does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Rebuild(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.UI.CanvasUpdate _executing;translator.Get(L, 2, out _executing); + + gen_to_be_invoked.Rebuild( _executing ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LayoutComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.LayoutComplete( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GraphicUpdateComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.GraphicUpdateComplete( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsActive(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsActive( ); + 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_StopMovement(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.StopMovement( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnScroll(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _data = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnScroll( _data ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnInitializePotentialDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnInitializePotentialDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnBeginDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnBeginDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnEndDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnEndDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalculateLayoutInputHorizontal(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CalculateLayoutInputHorizontal( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalculateLayoutInputVertical(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CalculateLayoutInputVertical( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLayoutHorizontal(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetLayoutHorizontal( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLayoutVertical(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetLayoutVertical( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DONormalizedPos(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector2 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapping = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.DONormalizedPos( _endValue, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + UnityEngine.Vector2 _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DONormalizedPos( _endValue, _duration ); + 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 UnityEngine.UI.ScrollRect.DONormalizedPos!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOHorizontalNormalizedPos(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapping = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.DOHorizontalNormalizedPos( _endValue, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOHorizontalNormalizedPos( _endValue, _duration ); + 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 UnityEngine.UI.ScrollRect.DOHorizontalNormalizedPos!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOVerticalNormalizedPos(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapping = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.DOVerticalNormalizedPos( _endValue, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOVerticalNormalizedPos( _endValue, _duration ); + 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 UnityEngine.UI.ScrollRect.DOVerticalNormalizedPos!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_content(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.content); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_horizontal(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.horizontal); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_vertical(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.vertical); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_movementType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineUIScrollRectMovementType(L, gen_to_be_invoked.movementType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_elasticity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.elasticity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_inertia(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.inertia); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_decelerationRate(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.decelerationRate); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_scrollSensitivity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.scrollSensitivity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_viewport(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.viewport); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_horizontalScrollbar(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.horizontalScrollbar); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_verticalScrollbar(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.verticalScrollbar); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_horizontalScrollbarVisibility(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineUIScrollRectScrollbarVisibility(L, gen_to_be_invoked.horizontalScrollbarVisibility); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_verticalScrollbarVisibility(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineUIScrollRectScrollbarVisibility(L, gen_to_be_invoked.verticalScrollbarVisibility); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_horizontalScrollbarSpacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.horizontalScrollbarSpacing); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_verticalScrollbarSpacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.verticalScrollbarSpacing); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onValueChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onValueChanged); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_velocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.velocity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_normalizedPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.normalizedPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_horizontalNormalizedPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.horizontalNormalizedPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_verticalNormalizedPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.verticalNormalizedPosition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_minWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.minWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preferredWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.preferredWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_flexibleWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.flexibleWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_minHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.minHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preferredHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.preferredHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_flexibleHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.flexibleHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_layoutPriority(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.layoutPriority); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_content(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.content = (UnityEngine.RectTransform)translator.GetObject(L, 2, typeof(UnityEngine.RectTransform)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_horizontal(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.horizontal = 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_vertical(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.vertical = 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_movementType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + UnityEngine.UI.ScrollRect.MovementType gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.movementType = 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_elasticity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.elasticity = (float)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_inertia(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.inertia = 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_decelerationRate(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.decelerationRate = (float)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_scrollSensitivity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.scrollSensitivity = (float)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_viewport(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.viewport = (UnityEngine.RectTransform)translator.GetObject(L, 2, typeof(UnityEngine.RectTransform)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_horizontalScrollbar(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.horizontalScrollbar = (UnityEngine.UI.Scrollbar)translator.GetObject(L, 2, typeof(UnityEngine.UI.Scrollbar)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_verticalScrollbar(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.verticalScrollbar = (UnityEngine.UI.Scrollbar)translator.GetObject(L, 2, typeof(UnityEngine.UI.Scrollbar)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_horizontalScrollbarVisibility(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + UnityEngine.UI.ScrollRect.ScrollbarVisibility gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.horizontalScrollbarVisibility = 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_verticalScrollbarVisibility(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + UnityEngine.UI.ScrollRect.ScrollbarVisibility gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.verticalScrollbarVisibility = 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_horizontalScrollbarSpacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.horizontalScrollbarSpacing = (float)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_verticalScrollbarSpacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.verticalScrollbarSpacing = (float)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_onValueChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onValueChanged = (UnityEngine.UI.ScrollRect.ScrollRectEvent)translator.GetObject(L, 2, typeof(UnityEngine.UI.ScrollRect.ScrollRectEvent)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_velocity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.velocity = 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_normalizedPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + UnityEngine.Vector2 gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.normalizedPosition = 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_horizontalNormalizedPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.horizontalNormalizedPosition = (float)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_verticalNormalizedPosition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ScrollRect gen_to_be_invoked = (UnityEngine.UI.ScrollRect)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.verticalNormalizedPosition = (float)LuaAPI.lua_tonumber(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_UI_ScrollRect_ScrollRectEventWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_ScrollRect_ScrollRectEventWrap.cs new file mode 100644 index 000000000..078e8f569 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_ScrollRect_ScrollRectEventWrap.cs @@ -0,0 +1,84 @@ +#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 UnityEngineUIScrollRectScrollRectEventWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.ScrollRect.ScrollRectEvent); + 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) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new UnityEngine.UI.ScrollRect.ScrollRectEvent(); + 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 UnityEngine.UI.ScrollRect.ScrollRectEvent constructor!"); + + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_UI_ScrollbarWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_ScrollbarWrap.cs new file mode 100644 index 000000000..e09735dc2 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_ScrollbarWrap.cs @@ -0,0 +1,688 @@ +#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 UnityEngineUIScrollbarWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.Scrollbar); + Utils.BeginObjectRegister(type, L, translator, 0, 15, 6, 6); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetValueWithoutNotify", _m_SetValueWithoutNotify); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Rebuild", _m_Rebuild); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LayoutComplete", _m_LayoutComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GraphicUpdateComplete", _m_GraphicUpdateComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBeginDrag", _m_OnBeginDrag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnDrag", _m_OnDrag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerDown", _m_OnPointerDown); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerUp", _m_OnPointerUp); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnMove", _m_OnMove); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindSelectableOnLeft", _m_FindSelectableOnLeft); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindSelectableOnRight", _m_FindSelectableOnRight); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindSelectableOnUp", _m_FindSelectableOnUp); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindSelectableOnDown", _m_FindSelectableOnDown); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnInitializePotentialDrag", _m_OnInitializePotentialDrag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetDirection", _m_SetDirection); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "handleRect", _g_get_handleRect); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "direction", _g_get_direction); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "value", _g_get_value); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "size", _g_get_size); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "numberOfSteps", _g_get_numberOfSteps); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onValueChanged", _g_get_onValueChanged); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "handleRect", _s_set_handleRect); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "direction", _s_set_direction); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "value", _s_set_value); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "size", _s_set_size); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "numberOfSteps", _s_set_numberOfSteps); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onValueChanged", _s_set_onValueChanged); + + + 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, "UnityEngine.UI.Scrollbar does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetValueWithoutNotify(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Scrollbar gen_to_be_invoked = (UnityEngine.UI.Scrollbar)translator.FastGetCSObj(L, 1); + + + + { + float _input = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.SetValueWithoutNotify( _input ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Rebuild(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Scrollbar gen_to_be_invoked = (UnityEngine.UI.Scrollbar)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.UI.CanvasUpdate _executing;translator.Get(L, 2, out _executing); + + gen_to_be_invoked.Rebuild( _executing ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LayoutComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Scrollbar gen_to_be_invoked = (UnityEngine.UI.Scrollbar)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.LayoutComplete( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GraphicUpdateComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Scrollbar gen_to_be_invoked = (UnityEngine.UI.Scrollbar)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.GraphicUpdateComplete( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnBeginDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Scrollbar gen_to_be_invoked = (UnityEngine.UI.Scrollbar)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnBeginDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Scrollbar gen_to_be_invoked = (UnityEngine.UI.Scrollbar)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerDown(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Scrollbar gen_to_be_invoked = (UnityEngine.UI.Scrollbar)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerDown( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerUp(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Scrollbar gen_to_be_invoked = (UnityEngine.UI.Scrollbar)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerUp( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnMove(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Scrollbar gen_to_be_invoked = (UnityEngine.UI.Scrollbar)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.AxisEventData _eventData = (UnityEngine.EventSystems.AxisEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.AxisEventData)); + + gen_to_be_invoked.OnMove( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FindSelectableOnLeft(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Scrollbar gen_to_be_invoked = (UnityEngine.UI.Scrollbar)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.FindSelectableOnLeft( ); + 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_FindSelectableOnRight(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Scrollbar gen_to_be_invoked = (UnityEngine.UI.Scrollbar)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.FindSelectableOnRight( ); + 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_FindSelectableOnUp(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Scrollbar gen_to_be_invoked = (UnityEngine.UI.Scrollbar)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.FindSelectableOnUp( ); + 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_FindSelectableOnDown(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Scrollbar gen_to_be_invoked = (UnityEngine.UI.Scrollbar)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.FindSelectableOnDown( ); + 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_OnInitializePotentialDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Scrollbar gen_to_be_invoked = (UnityEngine.UI.Scrollbar)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnInitializePotentialDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetDirection(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Scrollbar gen_to_be_invoked = (UnityEngine.UI.Scrollbar)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.UI.Scrollbar.Direction _direction;translator.Get(L, 2, out _direction); + bool _includeRectLayouts = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.SetDirection( _direction, _includeRectLayouts ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_handleRect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Scrollbar gen_to_be_invoked = (UnityEngine.UI.Scrollbar)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.handleRect); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_direction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Scrollbar gen_to_be_invoked = (UnityEngine.UI.Scrollbar)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.direction); + } 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); + + UnityEngine.UI.Scrollbar gen_to_be_invoked = (UnityEngine.UI.Scrollbar)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(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_size(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Scrollbar gen_to_be_invoked = (UnityEngine.UI.Scrollbar)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.size); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_numberOfSteps(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Scrollbar gen_to_be_invoked = (UnityEngine.UI.Scrollbar)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.numberOfSteps); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onValueChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Scrollbar gen_to_be_invoked = (UnityEngine.UI.Scrollbar)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onValueChanged); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_handleRect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Scrollbar gen_to_be_invoked = (UnityEngine.UI.Scrollbar)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.handleRect = (UnityEngine.RectTransform)translator.GetObject(L, 2, typeof(UnityEngine.RectTransform)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_direction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Scrollbar gen_to_be_invoked = (UnityEngine.UI.Scrollbar)translator.FastGetCSObj(L, 1); + UnityEngine.UI.Scrollbar.Direction gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.direction = 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_value(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Scrollbar gen_to_be_invoked = (UnityEngine.UI.Scrollbar)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.value = (float)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_size(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Scrollbar gen_to_be_invoked = (UnityEngine.UI.Scrollbar)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.size = (float)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_numberOfSteps(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Scrollbar gen_to_be_invoked = (UnityEngine.UI.Scrollbar)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.numberOfSteps = 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_onValueChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Scrollbar gen_to_be_invoked = (UnityEngine.UI.Scrollbar)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onValueChanged = (UnityEngine.UI.Scrollbar.ScrollEvent)translator.GetObject(L, 2, typeof(UnityEngine.UI.Scrollbar.ScrollEvent)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_UI_SelectableWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_SelectableWrap.cs new file mode 100644 index 000000000..ce33737dc --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_SelectableWrap.cs @@ -0,0 +1,794 @@ +#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 UnityEngineUISelectableWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.Selectable); + Utils.BeginObjectRegister(type, L, translator, 0, 14, 9, 8); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsInteractable", _m_IsInteractable); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindSelectable", _m_FindSelectable); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindSelectableOnLeft", _m_FindSelectableOnLeft); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindSelectableOnRight", _m_FindSelectableOnRight); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindSelectableOnUp", _m_FindSelectableOnUp); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindSelectableOnDown", _m_FindSelectableOnDown); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnMove", _m_OnMove); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerDown", _m_OnPointerDown); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerUp", _m_OnPointerUp); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerEnter", _m_OnPointerEnter); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerExit", _m_OnPointerExit); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnSelect", _m_OnSelect); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnDeselect", _m_OnDeselect); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Select", _m_Select); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "navigation", _g_get_navigation); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "transition", _g_get_transition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "colors", _g_get_colors); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "spriteState", _g_get_spriteState); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "animationTriggers", _g_get_animationTriggers); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "targetGraphic", _g_get_targetGraphic); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "interactable", _g_get_interactable); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "image", _g_get_image); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "animator", _g_get_animator); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "navigation", _s_set_navigation); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "transition", _s_set_transition); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "colors", _s_set_colors); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "spriteState", _s_set_spriteState); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "animationTriggers", _s_set_animationTriggers); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "targetGraphic", _s_set_targetGraphic); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "interactable", _s_set_interactable); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "image", _s_set_image); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 2, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "AllSelectablesNoAlloc", _m_AllSelectablesNoAlloc_xlua_st_); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "allSelectablesArray", _g_get_allSelectablesArray); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "allSelectableCount", _g_get_allSelectableCount); + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "UnityEngine.UI.Selectable does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AllSelectablesNoAlloc_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.UI.Selectable[] _selectables = (UnityEngine.UI.Selectable[])translator.GetObject(L, 1, typeof(UnityEngine.UI.Selectable[])); + + var gen_ret = UnityEngine.UI.Selectable.AllSelectablesNoAlloc( _selectables ); + 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_IsInteractable(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.IsInteractable( ); + 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_FindSelectable(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector3 _dir;translator.Get(L, 2, out _dir); + + var gen_ret = gen_to_be_invoked.FindSelectable( _dir ); + 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_FindSelectableOnLeft(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.FindSelectableOnLeft( ); + 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_FindSelectableOnRight(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.FindSelectableOnRight( ); + 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_FindSelectableOnUp(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.FindSelectableOnUp( ); + 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_FindSelectableOnDown(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.FindSelectableOnDown( ); + 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_OnMove(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.AxisEventData _eventData = (UnityEngine.EventSystems.AxisEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.AxisEventData)); + + gen_to_be_invoked.OnMove( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerDown(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerDown( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerUp(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerUp( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerEnter(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerEnter( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerExit(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerExit( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnSelect(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.BaseEventData _eventData = (UnityEngine.EventSystems.BaseEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.BaseEventData)); + + gen_to_be_invoked.OnSelect( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnDeselect(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.BaseEventData _eventData = (UnityEngine.EventSystems.BaseEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.BaseEventData)); + + gen_to_be_invoked.OnDeselect( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Select(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Select( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_allSelectablesArray(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UnityEngine.UI.Selectable.allSelectablesArray); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_allSelectableCount(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.UI.Selectable.allSelectableCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_navigation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.navigation); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_transition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.transition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_colors(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.colors); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_spriteState(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.spriteState); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_animationTriggers(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.animationTriggers); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_targetGraphic(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.targetGraphic); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_interactable(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.interactable); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_image(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.image); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_animator(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.animator); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_navigation(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + UnityEngine.UI.Navigation gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.navigation = 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_transition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + UnityEngine.UI.Selectable.Transition gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.transition = 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_colors(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + UnityEngine.UI.ColorBlock gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.colors = 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_spriteState(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + UnityEngine.UI.SpriteState gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.spriteState = 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_animationTriggers(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.animationTriggers = (UnityEngine.UI.AnimationTriggers)translator.GetObject(L, 2, typeof(UnityEngine.UI.AnimationTriggers)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_targetGraphic(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.targetGraphic = (UnityEngine.UI.Graphic)translator.GetObject(L, 2, typeof(UnityEngine.UI.Graphic)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_interactable(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.interactable = 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_image(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Selectable gen_to_be_invoked = (UnityEngine.UI.Selectable)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.image = (UnityEngine.UI.Image)translator.GetObject(L, 2, typeof(UnityEngine.UI.Image)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_UI_SliderWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_SliderWrap.cs new file mode 100644 index 000000000..d15097c4f --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_SliderWrap.cs @@ -0,0 +1,771 @@ +#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; +using DG.Tweening; + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class UnityEngineUISliderWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.Slider); + Utils.BeginObjectRegister(type, L, translator, 0, 14, 9, 9); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetValueWithoutNotify", _m_SetValueWithoutNotify); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Rebuild", _m_Rebuild); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LayoutComplete", _m_LayoutComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GraphicUpdateComplete", _m_GraphicUpdateComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerDown", _m_OnPointerDown); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnDrag", _m_OnDrag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnMove", _m_OnMove); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindSelectableOnLeft", _m_FindSelectableOnLeft); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindSelectableOnRight", _m_FindSelectableOnRight); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindSelectableOnUp", _m_FindSelectableOnUp); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FindSelectableOnDown", _m_FindSelectableOnDown); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnInitializePotentialDrag", _m_OnInitializePotentialDrag); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetDirection", _m_SetDirection); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOValue", _m_DOValue); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fillRect", _g_get_fillRect); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "handleRect", _g_get_handleRect); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "direction", _g_get_direction); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "minValue", _g_get_minValue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "maxValue", _g_get_maxValue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "wholeNumbers", _g_get_wholeNumbers); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "value", _g_get_value); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "normalizedValue", _g_get_normalizedValue); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onValueChanged", _g_get_onValueChanged); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fillRect", _s_set_fillRect); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "handleRect", _s_set_handleRect); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "direction", _s_set_direction); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "minValue", _s_set_minValue); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "maxValue", _s_set_maxValue); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "wholeNumbers", _s_set_wholeNumbers); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "value", _s_set_value); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "normalizedValue", _s_set_normalizedValue); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onValueChanged", _s_set_onValueChanged); + + + 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, "UnityEngine.UI.Slider does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetValueWithoutNotify(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + + + + { + float _input = (float)LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.SetValueWithoutNotify( _input ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Rebuild(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.UI.CanvasUpdate _executing;translator.Get(L, 2, out _executing); + + gen_to_be_invoked.Rebuild( _executing ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LayoutComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.LayoutComplete( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GraphicUpdateComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.GraphicUpdateComplete( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerDown(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerDown( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnMove(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.AxisEventData _eventData = (UnityEngine.EventSystems.AxisEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.AxisEventData)); + + gen_to_be_invoked.OnMove( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FindSelectableOnLeft(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.FindSelectableOnLeft( ); + 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_FindSelectableOnRight(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.FindSelectableOnRight( ); + 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_FindSelectableOnUp(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.FindSelectableOnUp( ); + 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_FindSelectableOnDown(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.FindSelectableOnDown( ); + 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_OnInitializePotentialDrag(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnInitializePotentialDrag( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetDirection(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.UI.Slider.Direction _direction;translator.Get(L, 2, out _direction); + bool _includeRectLayouts = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.SetDirection( _direction, _includeRectLayouts ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _snapping = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.DOValue( _endValue, _duration, _snapping ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOValue( _endValue, _duration ); + 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 UnityEngine.UI.Slider.DOValue!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fillRect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.fillRect); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_handleRect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.handleRect); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_direction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineUISliderDirection(L, gen_to_be_invoked.direction); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_minValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.minValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_maxValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.maxValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_wholeNumbers(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.wholeNumbers); + } 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); + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(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_normalizedValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.normalizedValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onValueChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onValueChanged); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_fillRect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.fillRect = (UnityEngine.RectTransform)translator.GetObject(L, 2, typeof(UnityEngine.RectTransform)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_handleRect(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.handleRect = (UnityEngine.RectTransform)translator.GetObject(L, 2, typeof(UnityEngine.RectTransform)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_direction(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + UnityEngine.UI.Slider.Direction gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.direction = 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_minValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.minValue = (float)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_maxValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.maxValue = (float)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_wholeNumbers(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.wholeNumbers = 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_value(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.value = (float)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_normalizedValue(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.normalizedValue = (float)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_onValueChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Slider gen_to_be_invoked = (UnityEngine.UI.Slider)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onValueChanged = (UnityEngine.UI.Slider.SliderEvent)translator.GetObject(L, 2, typeof(UnityEngine.UI.Slider.SliderEvent)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_UI_Slider_SliderEventWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_Slider_SliderEventWrap.cs new file mode 100644 index 000000000..579707e4c --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_Slider_SliderEventWrap.cs @@ -0,0 +1,84 @@ +#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 UnityEngineUISliderSliderEventWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.Slider.SliderEvent); + 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) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new UnityEngine.UI.Slider.SliderEvent(); + 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 UnityEngine.UI.Slider.SliderEvent constructor!"); + + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_UI_TextWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_TextWrap.cs new file mode 100644 index 000000000..f978829e0 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_TextWrap.cs @@ -0,0 +1,1016 @@ +#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; +using DG.Tweening; + +namespace XLua.CSObjectWrap +{ + using Utils = XLua.Utils; + public class UnityEngineUITextWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.Text); + Utils.BeginObjectRegister(type, L, translator, 0, 9, 24, 13); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "FontTextureChanged", _m_FontTextureChanged); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetGenerationSettings", _m_GetGenerationSettings); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CalculateLayoutInputHorizontal", _m_CalculateLayoutInputHorizontal); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CalculateLayoutInputVertical", _m_CalculateLayoutInputVertical); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOColor", _m_DOColor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOCounter", _m_DOCounter); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOFade", _m_DOFade); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOText", _m_DOText); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "DOBlendableColor", _m_DOBlendableColor); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "cachedTextGenerator", _g_get_cachedTextGenerator); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "cachedTextGeneratorForLayout", _g_get_cachedTextGeneratorForLayout); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "mainTexture", _g_get_mainTexture); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "font", _g_get_font); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "text", _g_get_text); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "supportRichText", _g_get_supportRichText); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "resizeTextForBestFit", _g_get_resizeTextForBestFit); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "resizeTextMinSize", _g_get_resizeTextMinSize); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "resizeTextMaxSize", _g_get_resizeTextMaxSize); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "alignment", _g_get_alignment); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "alignByGeometry", _g_get_alignByGeometry); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fontSize", _g_get_fontSize); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "horizontalOverflow", _g_get_horizontalOverflow); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "verticalOverflow", _g_get_verticalOverflow); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "lineSpacing", _g_get_lineSpacing); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fontStyle", _g_get_fontStyle); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "pixelsPerUnit", _g_get_pixelsPerUnit); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "minWidth", _g_get_minWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preferredWidth", _g_get_preferredWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "flexibleWidth", _g_get_flexibleWidth); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "minHeight", _g_get_minHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preferredHeight", _g_get_preferredHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "flexibleHeight", _g_get_flexibleHeight); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "layoutPriority", _g_get_layoutPriority); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "font", _s_set_font); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "text", _s_set_text); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "supportRichText", _s_set_supportRichText); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "resizeTextForBestFit", _s_set_resizeTextForBestFit); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "resizeTextMinSize", _s_set_resizeTextMinSize); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "resizeTextMaxSize", _s_set_resizeTextMaxSize); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "alignment", _s_set_alignment); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "alignByGeometry", _s_set_alignByGeometry); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fontSize", _s_set_fontSize); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "horizontalOverflow", _s_set_horizontalOverflow); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "verticalOverflow", _s_set_verticalOverflow); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "lineSpacing", _s_set_lineSpacing); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fontStyle", _s_set_fontStyle); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetTextAnchorPivot", _m_GetTextAnchorPivot_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "UnityEngine.UI.Text does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_FontTextureChanged(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.FontTextureChanged( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetGenerationSettings(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Vector2 _extents;translator.Get(L, 2, out _extents); + + var gen_ret = gen_to_be_invoked.GetGenerationSettings( _extents ); + 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_GetTextAnchorPivot_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.TextAnchor _anchor;translator.Get(L, 1, out _anchor); + + var gen_ret = UnityEngine.UI.Text.GetTextAnchorPivot( _anchor ); + translator.PushUnityEngineVector2(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_CalculateLayoutInputHorizontal(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CalculateLayoutInputHorizontal( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalculateLayoutInputVertical(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CalculateLayoutInputVertical( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Color _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOColor( _endValue, _duration ); + 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_DOCounter(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 6&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)&& translator.Assignable(L, 6)) + { + int _fromValue = LuaAPI.xlua_tointeger(L, 2); + int _endValue = LuaAPI.xlua_tointeger(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + bool _addThousandsSeparator = LuaAPI.lua_toboolean(L, 5); + System.Globalization.CultureInfo _culture = (System.Globalization.CultureInfo)translator.GetObject(L, 6, typeof(System.Globalization.CultureInfo)); + + var gen_ret = gen_to_be_invoked.DOCounter( _fromValue, _endValue, _duration, _addThousandsSeparator, _culture ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 5)) + { + int _fromValue = LuaAPI.xlua_tointeger(L, 2); + int _endValue = LuaAPI.xlua_tointeger(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + bool _addThousandsSeparator = LuaAPI.lua_toboolean(L, 5); + + var gen_ret = gen_to_be_invoked.DOCounter( _fromValue, _endValue, _duration, _addThousandsSeparator ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + int _fromValue = LuaAPI.xlua_tointeger(L, 2); + int _endValue = LuaAPI.xlua_tointeger(L, 3); + float _duration = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = gen_to_be_invoked.DOCounter( _fromValue, _endValue, _duration ); + 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 UnityEngine.UI.Text.DOCounter!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOFade(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + + + + { + float _endValue = (float)LuaAPI.lua_tonumber(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOFade( _endValue, _duration ); + 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_DOText(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 6&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)&& (LuaAPI.lua_isnil(L, 6) || LuaAPI.lua_type(L, 6) == LuaTypes.LUA_TSTRING)) + { + string _endValue = LuaAPI.lua_tostring(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _richTextEnabled = LuaAPI.lua_toboolean(L, 4); + DG.Tweening.ScrambleMode _scrambleMode;translator.Get(L, 5, out _scrambleMode); + string _scrambleChars = LuaAPI.lua_tostring(L, 6); + + var gen_ret = gen_to_be_invoked.DOText( _endValue, _duration, _richTextEnabled, _scrambleMode, _scrambleChars ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 5&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)&& translator.Assignable(L, 5)) + { + string _endValue = LuaAPI.lua_tostring(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _richTextEnabled = LuaAPI.lua_toboolean(L, 4); + DG.Tweening.ScrambleMode _scrambleMode;translator.Get(L, 5, out _scrambleMode); + + var gen_ret = gen_to_be_invoked.DOText( _endValue, _duration, _richTextEnabled, _scrambleMode ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + string _endValue = LuaAPI.lua_tostring(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + bool _richTextEnabled = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = gen_to_be_invoked.DOText( _endValue, _duration, _richTextEnabled ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + string _endValue = LuaAPI.lua_tostring(L, 2); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOText( _endValue, _duration ); + 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 UnityEngine.UI.Text.DOText!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_DOBlendableColor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.Color _endValue;translator.Get(L, 2, out _endValue); + float _duration = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = gen_to_be_invoked.DOBlendableColor( _endValue, _duration ); + 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_cachedTextGenerator(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.cachedTextGenerator); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_cachedTextGeneratorForLayout(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.cachedTextGeneratorForLayout); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_mainTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.mainTexture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_font(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.font); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_text(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.text); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_supportRichText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.supportRichText); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_resizeTextForBestFit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.resizeTextForBestFit); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_resizeTextMinSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.resizeTextMinSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_resizeTextMaxSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.resizeTextMaxSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_alignment(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineTextAnchor(L, gen_to_be_invoked.alignment); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_alignByGeometry(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.alignByGeometry); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fontSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.fontSize); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_horizontalOverflow(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.horizontalOverflow); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_verticalOverflow(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.verticalOverflow); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_lineSpacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.lineSpacing); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fontStyle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.fontStyle); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_pixelsPerUnit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.pixelsPerUnit); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_minWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.minWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preferredWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.preferredWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_flexibleWidth(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.flexibleWidth); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_minHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.minHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preferredHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.preferredHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_flexibleHeight(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.flexibleHeight); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_layoutPriority(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.layoutPriority); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_font(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.font = (UnityEngine.Font)translator.GetObject(L, 2, typeof(UnityEngine.Font)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_text(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.text = 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_supportRichText(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.supportRichText = 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_resizeTextForBestFit(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.resizeTextForBestFit = 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_resizeTextMinSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.resizeTextMinSize = 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_resizeTextMaxSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.resizeTextMaxSize = 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_alignment(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + UnityEngine.TextAnchor gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.alignment = 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_alignByGeometry(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.alignByGeometry = 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_fontSize(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.fontSize = 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_horizontalOverflow(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + UnityEngine.HorizontalWrapMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.horizontalOverflow = 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_verticalOverflow(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + UnityEngine.VerticalWrapMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.verticalOverflow = 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_lineSpacing(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.lineSpacing = (float)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_fontStyle(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Text gen_to_be_invoked = (UnityEngine.UI.Text)translator.FastGetCSObj(L, 1); + UnityEngine.FontStyle gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.fontStyle = gen_value; + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_UI_ToggleGroupWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_ToggleGroupWrap.cs new file mode 100644 index 000000000..754ae327e --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_ToggleGroupWrap.cs @@ -0,0 +1,357 @@ +#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 UnityEngineUIToggleGroupWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.ToggleGroup); + Utils.BeginObjectRegister(type, L, translator, 0, 8, 1, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "NotifyToggleOn", _m_NotifyToggleOn); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnregisterToggle", _m_UnregisterToggle); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "RegisterToggle", _m_RegisterToggle); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "EnsureValidState", _m_EnsureValidState); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "AnyTogglesOn", _m_AnyTogglesOn); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ActiveToggles", _m_ActiveToggles); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetFirstActiveToggle", _m_GetFirstActiveToggle); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetAllTogglesOff", _m_SetAllTogglesOff); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "allowSwitchOff", _g_get_allowSwitchOff); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "allowSwitchOff", _s_set_allowSwitchOff); + + + 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, "UnityEngine.UI.ToggleGroup does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_NotifyToggleOn(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.ToggleGroup gen_to_be_invoked = (UnityEngine.UI.ToggleGroup)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)) + { + UnityEngine.UI.Toggle _toggle = (UnityEngine.UI.Toggle)translator.GetObject(L, 2, typeof(UnityEngine.UI.Toggle)); + bool _sendCallback = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.NotifyToggleOn( _toggle, _sendCallback ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.UI.Toggle _toggle = (UnityEngine.UI.Toggle)translator.GetObject(L, 2, typeof(UnityEngine.UI.Toggle)); + + gen_to_be_invoked.NotifyToggleOn( _toggle ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.UI.ToggleGroup.NotifyToggleOn!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UnregisterToggle(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.ToggleGroup gen_to_be_invoked = (UnityEngine.UI.ToggleGroup)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.UI.Toggle _toggle = (UnityEngine.UI.Toggle)translator.GetObject(L, 2, typeof(UnityEngine.UI.Toggle)); + + gen_to_be_invoked.UnregisterToggle( _toggle ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RegisterToggle(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.ToggleGroup gen_to_be_invoked = (UnityEngine.UI.ToggleGroup)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.UI.Toggle _toggle = (UnityEngine.UI.Toggle)translator.GetObject(L, 2, typeof(UnityEngine.UI.Toggle)); + + gen_to_be_invoked.RegisterToggle( _toggle ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_EnsureValidState(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.ToggleGroup gen_to_be_invoked = (UnityEngine.UI.ToggleGroup)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.EnsureValidState( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_AnyTogglesOn(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.ToggleGroup gen_to_be_invoked = (UnityEngine.UI.ToggleGroup)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.AnyTogglesOn( ); + 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_ActiveToggles(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.ToggleGroup gen_to_be_invoked = (UnityEngine.UI.ToggleGroup)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.ActiveToggles( ); + 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_GetFirstActiveToggle(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.ToggleGroup gen_to_be_invoked = (UnityEngine.UI.ToggleGroup)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetFirstActiveToggle( ); + 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_SetAllTogglesOff(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.ToggleGroup gen_to_be_invoked = (UnityEngine.UI.ToggleGroup)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _sendCallback = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.SetAllTogglesOff( _sendCallback ); + + + + return 0; + } + if(gen_param_count == 1) + { + + gen_to_be_invoked.SetAllTogglesOff( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.UI.ToggleGroup.SetAllTogglesOff!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_allowSwitchOff(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ToggleGroup gen_to_be_invoked = (UnityEngine.UI.ToggleGroup)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.allowSwitchOff); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_allowSwitchOff(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.ToggleGroup gen_to_be_invoked = (UnityEngine.UI.ToggleGroup)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.allowSwitchOff = LuaAPI.lua_toboolean(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_UI_ToggleWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_ToggleWrap.cs new file mode 100644 index 000000000..362851417 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_ToggleWrap.cs @@ -0,0 +1,395 @@ +#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 UnityEngineUIToggleWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.Toggle); + Utils.BeginObjectRegister(type, L, translator, 0, 6, 5, 5); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Rebuild", _m_Rebuild); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "LayoutComplete", _m_LayoutComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GraphicUpdateComplete", _m_GraphicUpdateComplete); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetIsOnWithoutNotify", _m_SetIsOnWithoutNotify); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPointerClick", _m_OnPointerClick); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnSubmit", _m_OnSubmit); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "group", _g_get_group); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isOn", _g_get_isOn); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "toggleTransition", _g_get_toggleTransition); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "graphic", _g_get_graphic); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "onValueChanged", _g_get_onValueChanged); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "group", _s_set_group); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "isOn", _s_set_isOn); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "toggleTransition", _s_set_toggleTransition); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "graphic", _s_set_graphic); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "onValueChanged", _s_set_onValueChanged); + + + 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, "UnityEngine.UI.Toggle does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Rebuild(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Toggle gen_to_be_invoked = (UnityEngine.UI.Toggle)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.UI.CanvasUpdate _executing;translator.Get(L, 2, out _executing); + + gen_to_be_invoked.Rebuild( _executing ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_LayoutComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Toggle gen_to_be_invoked = (UnityEngine.UI.Toggle)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.LayoutComplete( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GraphicUpdateComplete(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Toggle gen_to_be_invoked = (UnityEngine.UI.Toggle)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.GraphicUpdateComplete( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetIsOnWithoutNotify(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Toggle gen_to_be_invoked = (UnityEngine.UI.Toggle)translator.FastGetCSObj(L, 1); + + + + { + bool _value = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.SetIsOnWithoutNotify( _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnPointerClick(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Toggle gen_to_be_invoked = (UnityEngine.UI.Toggle)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.PointerEventData _eventData = (UnityEngine.EventSystems.PointerEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.PointerEventData)); + + gen_to_be_invoked.OnPointerClick( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_OnSubmit(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.Toggle gen_to_be_invoked = (UnityEngine.UI.Toggle)translator.FastGetCSObj(L, 1); + + + + { + UnityEngine.EventSystems.BaseEventData _eventData = (UnityEngine.EventSystems.BaseEventData)translator.GetObject(L, 2, typeof(UnityEngine.EventSystems.BaseEventData)); + + gen_to_be_invoked.OnSubmit( _eventData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_group(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Toggle gen_to_be_invoked = (UnityEngine.UI.Toggle)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.group); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isOn(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Toggle gen_to_be_invoked = (UnityEngine.UI.Toggle)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isOn); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_toggleTransition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Toggle gen_to_be_invoked = (UnityEngine.UI.Toggle)translator.FastGetCSObj(L, 1); + translator.PushUnityEngineUIToggleToggleTransition(L, gen_to_be_invoked.toggleTransition); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_graphic(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Toggle gen_to_be_invoked = (UnityEngine.UI.Toggle)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.graphic); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_onValueChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Toggle gen_to_be_invoked = (UnityEngine.UI.Toggle)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.onValueChanged); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_group(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Toggle gen_to_be_invoked = (UnityEngine.UI.Toggle)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.group = (UnityEngine.UI.ToggleGroup)translator.GetObject(L, 2, typeof(UnityEngine.UI.ToggleGroup)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_isOn(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Toggle gen_to_be_invoked = (UnityEngine.UI.Toggle)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.isOn = 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_toggleTransition(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Toggle gen_to_be_invoked = (UnityEngine.UI.Toggle)translator.FastGetCSObj(L, 1); + UnityEngine.UI.Toggle.ToggleTransition gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.toggleTransition = 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_graphic(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Toggle gen_to_be_invoked = (UnityEngine.UI.Toggle)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.graphic = (UnityEngine.UI.Graphic)translator.GetObject(L, 2, typeof(UnityEngine.UI.Graphic)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_onValueChanged(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.UI.Toggle gen_to_be_invoked = (UnityEngine.UI.Toggle)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.onValueChanged = (UnityEngine.UI.Toggle.ToggleEvent)translator.GetObject(L, 2, typeof(UnityEngine.UI.Toggle.ToggleEvent)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_UI_Toggle_ToggleEventWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_Toggle_ToggleEventWrap.cs new file mode 100644 index 000000000..0165ca146 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_Toggle_ToggleEventWrap.cs @@ -0,0 +1,84 @@ +#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 UnityEngineUIToggleToggleEventWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.Toggle.ToggleEvent); + 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) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + if(LuaAPI.lua_gettop(L) == 1) + { + + var gen_ret = new UnityEngine.UI.Toggle.ToggleEvent(); + 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 UnityEngine.UI.Toggle.ToggleEvent constructor!"); + + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_UI_VerticalLayoutGroupWrap.cs b/Assets/XLua/Gen/UnityEngine_UI_VerticalLayoutGroupWrap.cs new file mode 100644 index 000000000..438265228 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_UI_VerticalLayoutGroupWrap.cs @@ -0,0 +1,179 @@ +#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 UnityEngineUIVerticalLayoutGroupWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.UI.VerticalLayoutGroup); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CalculateLayoutInputHorizontal", _m_CalculateLayoutInputHorizontal); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "CalculateLayoutInputVertical", _m_CalculateLayoutInputVertical); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLayoutHorizontal", _m_SetLayoutHorizontal); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLayoutVertical", _m_SetLayoutVertical); + + + + + + 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, "UnityEngine.UI.VerticalLayoutGroup does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalculateLayoutInputHorizontal(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.VerticalLayoutGroup gen_to_be_invoked = (UnityEngine.UI.VerticalLayoutGroup)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CalculateLayoutInputHorizontal( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_CalculateLayoutInputVertical(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.VerticalLayoutGroup gen_to_be_invoked = (UnityEngine.UI.VerticalLayoutGroup)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.CalculateLayoutInputVertical( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLayoutHorizontal(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.VerticalLayoutGroup gen_to_be_invoked = (UnityEngine.UI.VerticalLayoutGroup)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetLayoutHorizontal( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetLayoutVertical(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.UI.VerticalLayoutGroup gen_to_be_invoked = (UnityEngine.UI.VerticalLayoutGroup)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.SetLayoutVertical( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_Vector2Wrap.cs b/Assets/XLua/Gen/UnityEngine_Vector2Wrap.cs new file mode 100644 index 000000000..fd8b03066 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_Vector2Wrap.cs @@ -0,0 +1,1292 @@ +#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 UnityEngineVector2Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Vector2); + Utils.BeginObjectRegister(type, L, translator, 6, 7, 5, 2); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__add", __AddMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__sub", __SubMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__mul", __MulMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__div", __DivMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__unm", __UnmMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__eq", __EqMeta); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Set", _m_Set); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Scale", _m_Scale); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Normalize", _m_Normalize); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashCode", _m_GetHashCode); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Equals", _m_Equals); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SqrMagnitude", _m_SqrMagnitude); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "normalized", _g_get_normalized); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "magnitude", _g_get_magnitude); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sqrMagnitude", _g_get_sqrMagnitude); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "x", _g_get_x); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "y", _g_get_y); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "x", _s_set_x); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "y", _s_set_y); + + + Utils.EndObjectRegister(type, L, translator, __CSIndexer, __NewIndexer, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 18, 8, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Lerp", _m_Lerp_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LerpUnclamped", _m_LerpUnclamped_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "MoveTowards", _m_MoveTowards_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Scale", _m_Scale_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Reflect", _m_Reflect_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Perpendicular", _m_Perpendicular_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Dot", _m_Dot_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Angle", _m_Angle_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SignedAngle", _m_SignedAngle_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Distance", _m_Distance_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ClampMagnitude", _m_ClampMagnitude_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SqrMagnitude", _m_SqrMagnitude_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Min", _m_Min_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Max", _m_Max_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SmoothDamp", _m_SmoothDamp_xlua_st_); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "kEpsilon", UnityEngine.Vector2.kEpsilon); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "kEpsilonNormalSqrt", UnityEngine.Vector2.kEpsilonNormalSqrt); + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "zero", _g_get_zero); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "one", _g_get_one); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "up", _g_get_up); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "down", _g_get_down); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "left", _g_get_left); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "right", _g_get_right); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "positiveInfinity", _g_get_positiveInfinity); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "negativeInfinity", _g_get_negativeInfinity); + + + + 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 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = new UnityEngine.Vector2(_x, _y); + translator.PushUnityEngineVector2(L, gen_ret); + + return 1; + } + + if (LuaAPI.lua_gettop(L) == 1) + { + translator.PushUnityEngineVector2(L, default(UnityEngine.Vector2)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Vector2 constructor!"); + + } + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __CSIndexer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + if (translator.Assignable(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + + UnityEngine.Vector2 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + int index = LuaAPI.xlua_tointeger(L, 2); + LuaAPI.lua_pushboolean(L, true); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked[index]); + return 2; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __NewIndexer(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + try { + + if (translator.Assignable(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + + UnityEngine.Vector2 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + int key = LuaAPI.xlua_tointeger(L, 2); + gen_to_be_invoked[key] = (float)LuaAPI.lua_tonumber(L, 3); + LuaAPI.lua_pushboolean(L, true); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __AddMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + UnityEngine.Vector2 leftside;translator.Get(L, 1, out leftside); + UnityEngine.Vector2 rightside;translator.Get(L, 2, out rightside); + + translator.PushUnityEngineVector2(L, leftside + rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of + operator, need UnityEngine.Vector2!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __SubMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + UnityEngine.Vector2 leftside;translator.Get(L, 1, out leftside); + UnityEngine.Vector2 rightside;translator.Get(L, 2, out rightside); + + translator.PushUnityEngineVector2(L, leftside - rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of - operator, need UnityEngine.Vector2!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __MulMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + UnityEngine.Vector2 leftside;translator.Get(L, 1, out leftside); + UnityEngine.Vector2 rightside;translator.Get(L, 2, out rightside); + + translator.PushUnityEngineVector2(L, leftside * rightside); + + return 1; + } + + + if (translator.Assignable(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + UnityEngine.Vector2 leftside;translator.Get(L, 1, out leftside); + float rightside = (float)LuaAPI.lua_tonumber(L, 2); + + translator.PushUnityEngineVector2(L, leftside * rightside); + + return 1; + } + + + if (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) && translator.Assignable(L, 2)) + { + float leftside = (float)LuaAPI.lua_tonumber(L, 1); + UnityEngine.Vector2 rightside;translator.Get(L, 2, out rightside); + + translator.PushUnityEngineVector2(L, leftside * rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of * operator, need UnityEngine.Vector2!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __DivMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + UnityEngine.Vector2 leftside;translator.Get(L, 1, out leftside); + UnityEngine.Vector2 rightside;translator.Get(L, 2, out rightside); + + translator.PushUnityEngineVector2(L, leftside / rightside); + + return 1; + } + + + if (translator.Assignable(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + UnityEngine.Vector2 leftside;translator.Get(L, 1, out leftside); + float rightside = (float)LuaAPI.lua_tonumber(L, 2); + + translator.PushUnityEngineVector2(L, leftside / rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of / operator, need UnityEngine.Vector2!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __UnmMeta(RealStatePtr L) + { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + try { + UnityEngine.Vector2 rightside;translator.Get(L, 1, out rightside); + translator.PushUnityEngineVector2(L, - rightside); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __EqMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + UnityEngine.Vector2 leftside;translator.Get(L, 1, out leftside); + UnityEngine.Vector2 rightside;translator.Get(L, 2, out rightside); + + LuaAPI.lua_pushboolean(L, leftside == rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of == operator, need UnityEngine.Vector2!"); + + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Set(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Vector2 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + float _newX = (float)LuaAPI.lua_tonumber(L, 2); + float _newY = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.Set( _newX, _newY ); + + + translator.UpdateUnityEngineVector2(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Lerp_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector2 _a;translator.Get(L, 1, out _a); + UnityEngine.Vector2 _b;translator.Get(L, 2, out _b); + float _t = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Vector2.Lerp( _a, _b, _t ); + translator.PushUnityEngineVector2(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_LerpUnclamped_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector2 _a;translator.Get(L, 1, out _a); + UnityEngine.Vector2 _b;translator.Get(L, 2, out _b); + float _t = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Vector2.LerpUnclamped( _a, _b, _t ); + translator.PushUnityEngineVector2(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_MoveTowards_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector2 _current;translator.Get(L, 1, out _current); + UnityEngine.Vector2 _target;translator.Get(L, 2, out _target); + float _maxDistanceDelta = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Vector2.MoveTowards( _current, _target, _maxDistanceDelta ); + translator.PushUnityEngineVector2(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_Scale_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector2 _a;translator.Get(L, 1, out _a); + UnityEngine.Vector2 _b;translator.Get(L, 2, out _b); + + var gen_ret = UnityEngine.Vector2.Scale( _a, _b ); + translator.PushUnityEngineVector2(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_Scale(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Vector2 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.Vector2 _scale;translator.Get(L, 2, out _scale); + + gen_to_be_invoked.Scale( _scale ); + + + translator.UpdateUnityEngineVector2(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Normalize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Vector2 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + gen_to_be_invoked.Normalize( ); + + + translator.UpdateUnityEngineVector2(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Vector2 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.ToString( ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.UpdateUnityEngineVector2(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _format = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.ToString( _format ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.UpdateUnityEngineVector2(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _format = LuaAPI.lua_tostring(L, 2); + System.IFormatProvider _formatProvider = (System.IFormatProvider)translator.GetObject(L, 3, typeof(System.IFormatProvider)); + + var gen_ret = gen_to_be_invoked.ToString( _format, _formatProvider ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.UpdateUnityEngineVector2(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Vector2.ToString!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetHashCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Vector2 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.GetHashCode( ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + translator.UpdateUnityEngineVector2(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Equals(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Vector2 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _other = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.Equals( _other ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.UpdateUnityEngineVector2(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector2 _other;translator.Get(L, 2, out _other); + + var gen_ret = gen_to_be_invoked.Equals( _other ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.UpdateUnityEngineVector2(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Vector2.Equals!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Reflect_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector2 _inDirection;translator.Get(L, 1, out _inDirection); + UnityEngine.Vector2 _inNormal;translator.Get(L, 2, out _inNormal); + + var gen_ret = UnityEngine.Vector2.Reflect( _inDirection, _inNormal ); + translator.PushUnityEngineVector2(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_Perpendicular_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector2 _inDirection;translator.Get(L, 1, out _inDirection); + + var gen_ret = UnityEngine.Vector2.Perpendicular( _inDirection ); + translator.PushUnityEngineVector2(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_Dot_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector2 _lhs;translator.Get(L, 1, out _lhs); + UnityEngine.Vector2 _rhs;translator.Get(L, 2, out _rhs); + + var gen_ret = UnityEngine.Vector2.Dot( _lhs, _rhs ); + LuaAPI.lua_pushnumber(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_Angle_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector2 _from;translator.Get(L, 1, out _from); + UnityEngine.Vector2 _to;translator.Get(L, 2, out _to); + + var gen_ret = UnityEngine.Vector2.Angle( _from, _to ); + LuaAPI.lua_pushnumber(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_SignedAngle_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector2 _from;translator.Get(L, 1, out _from); + UnityEngine.Vector2 _to;translator.Get(L, 2, out _to); + + var gen_ret = UnityEngine.Vector2.SignedAngle( _from, _to ); + LuaAPI.lua_pushnumber(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_Distance_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector2 _a;translator.Get(L, 1, out _a); + UnityEngine.Vector2 _b;translator.Get(L, 2, out _b); + + var gen_ret = UnityEngine.Vector2.Distance( _a, _b ); + LuaAPI.lua_pushnumber(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_ClampMagnitude_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector2 _vector;translator.Get(L, 1, out _vector); + float _maxLength = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = UnityEngine.Vector2.ClampMagnitude( _vector, _maxLength ); + translator.PushUnityEngineVector2(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_SqrMagnitude_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector2 _a;translator.Get(L, 1, out _a); + + var gen_ret = UnityEngine.Vector2.SqrMagnitude( _a ); + LuaAPI.lua_pushnumber(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_SqrMagnitude(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Vector2 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.SqrMagnitude( ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + translator.UpdateUnityEngineVector2(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Min_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector2 _lhs;translator.Get(L, 1, out _lhs); + UnityEngine.Vector2 _rhs;translator.Get(L, 2, out _rhs); + + var gen_ret = UnityEngine.Vector2.Min( _lhs, _rhs ); + translator.PushUnityEngineVector2(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_Max_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector2 _lhs;translator.Get(L, 1, out _lhs); + UnityEngine.Vector2 _rhs;translator.Get(L, 2, out _rhs); + + var gen_ret = UnityEngine.Vector2.Max( _lhs, _rhs ); + translator.PushUnityEngineVector2(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_SmoothDamp_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector2 _current;translator.Get(L, 1, out _current); + UnityEngine.Vector2 _target;translator.Get(L, 2, out _target); + UnityEngine.Vector2 _currentVelocity;translator.Get(L, 3, out _currentVelocity); + float _smoothTime = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = UnityEngine.Vector2.SmoothDamp( _current, _target, ref _currentVelocity, _smoothTime ); + translator.PushUnityEngineVector2(L, gen_ret); + translator.PushUnityEngineVector2(L, _currentVelocity); + translator.UpdateUnityEngineVector2(L, 3, _currentVelocity); + + + + + return 2; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Vector2 _current;translator.Get(L, 1, out _current); + UnityEngine.Vector2 _target;translator.Get(L, 2, out _target); + UnityEngine.Vector2 _currentVelocity;translator.Get(L, 3, out _currentVelocity); + float _smoothTime = (float)LuaAPI.lua_tonumber(L, 4); + float _maxSpeed = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = UnityEngine.Vector2.SmoothDamp( _current, _target, ref _currentVelocity, _smoothTime, _maxSpeed ); + translator.PushUnityEngineVector2(L, gen_ret); + translator.PushUnityEngineVector2(L, _currentVelocity); + translator.UpdateUnityEngineVector2(L, 3, _currentVelocity); + + + + + return 2; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Vector2 _current;translator.Get(L, 1, out _current); + UnityEngine.Vector2 _target;translator.Get(L, 2, out _target); + UnityEngine.Vector2 _currentVelocity;translator.Get(L, 3, out _currentVelocity); + float _smoothTime = (float)LuaAPI.lua_tonumber(L, 4); + float _maxSpeed = (float)LuaAPI.lua_tonumber(L, 5); + float _deltaTime = (float)LuaAPI.lua_tonumber(L, 6); + + var gen_ret = UnityEngine.Vector2.SmoothDamp( _current, _target, ref _currentVelocity, _smoothTime, _maxSpeed, _deltaTime ); + translator.PushUnityEngineVector2(L, gen_ret); + translator.PushUnityEngineVector2(L, _currentVelocity); + translator.UpdateUnityEngineVector2(L, 3, _currentVelocity); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Vector2.SmoothDamp!"); + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_normalized(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Vector2 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector2(L, gen_to_be_invoked.normalized); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_magnitude(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Vector2 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.magnitude); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sqrMagnitude(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Vector2 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.sqrMagnitude); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_zero(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineVector2(L, UnityEngine.Vector2.zero); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_one(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineVector2(L, UnityEngine.Vector2.one); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_up(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineVector2(L, UnityEngine.Vector2.up); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_down(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineVector2(L, UnityEngine.Vector2.down); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_left(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineVector2(L, UnityEngine.Vector2.left); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_right(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineVector2(L, UnityEngine.Vector2.right); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_positiveInfinity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineVector2(L, UnityEngine.Vector2.positiveInfinity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_negativeInfinity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineVector2(L, UnityEngine.Vector2.negativeInfinity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_x(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Vector2 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.x); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_y(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Vector2 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.y); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_x(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Vector2 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.x = (float)LuaAPI.lua_tonumber(L, 2); + + translator.UpdateUnityEngineVector2(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_y(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Vector2 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.y = (float)LuaAPI.lua_tonumber(L, 2); + + translator.UpdateUnityEngineVector2(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_Vector3Wrap.cs b/Assets/XLua/Gen/UnityEngine_Vector3Wrap.cs new file mode 100644 index 000000000..3d6f2526b --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_Vector3Wrap.cs @@ -0,0 +1,1576 @@ +#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 UnityEngineVector3Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Vector3); + Utils.BeginObjectRegister(type, L, translator, 6, 6, 6, 3); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__add", __AddMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__sub", __SubMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__unm", __UnmMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__mul", __MulMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__div", __DivMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__eq", __EqMeta); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Set", _m_Set); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Scale", _m_Scale); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashCode", _m_GetHashCode); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Equals", _m_Equals); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Normalize", _m_Normalize); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "normalized", _g_get_normalized); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "magnitude", _g_get_magnitude); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sqrMagnitude", _g_get_sqrMagnitude); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "x", _g_get_x); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "y", _g_get_y); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "z", _g_get_z); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "x", _s_set_x); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "y", _s_set_y); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "z", _s_set_z); + + + Utils.EndObjectRegister(type, L, translator, __CSIndexer, __NewIndexer, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 26, 10, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Lerp", _m_Lerp_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LerpUnclamped", _m_LerpUnclamped_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "MoveTowards", _m_MoveTowards_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SmoothDamp", _m_SmoothDamp_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Scale", _m_Scale_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Cross", _m_Cross_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Reflect", _m_Reflect_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Normalize", _m_Normalize_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Dot", _m_Dot_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Project", _m_Project_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ProjectOnPlane", _m_ProjectOnPlane_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Angle", _m_Angle_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SignedAngle", _m_SignedAngle_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Distance", _m_Distance_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ClampMagnitude", _m_ClampMagnitude_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Magnitude", _m_Magnitude_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SqrMagnitude", _m_SqrMagnitude_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Min", _m_Min_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Max", _m_Max_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Slerp", _m_Slerp_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SlerpUnclamped", _m_SlerpUnclamped_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "OrthoNormalize", _m_OrthoNormalize_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "RotateTowards", _m_RotateTowards_xlua_st_); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "kEpsilon", UnityEngine.Vector3.kEpsilon); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "kEpsilonNormalSqrt", UnityEngine.Vector3.kEpsilonNormalSqrt); + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "zero", _g_get_zero); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "one", _g_get_one); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "forward", _g_get_forward); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "back", _g_get_back); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "up", _g_get_up); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "down", _g_get_down); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "left", _g_get_left); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "right", _g_get_right); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "positiveInfinity", _g_get_positiveInfinity); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "negativeInfinity", _g_get_negativeInfinity); + + + + 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) == 4 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = new UnityEngine.Vector3(_x, _y, _z); + translator.PushUnityEngineVector3(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 3 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = new UnityEngine.Vector3(_x, _y); + translator.PushUnityEngineVector3(L, gen_ret); + + return 1; + } + + if (LuaAPI.lua_gettop(L) == 1) + { + translator.PushUnityEngineVector3(L, default(UnityEngine.Vector3)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Vector3 constructor!"); + + } + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __CSIndexer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + if (translator.Assignable(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + + UnityEngine.Vector3 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + int index = LuaAPI.xlua_tointeger(L, 2); + LuaAPI.lua_pushboolean(L, true); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked[index]); + return 2; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __NewIndexer(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + try { + + if (translator.Assignable(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + + UnityEngine.Vector3 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + int key = LuaAPI.xlua_tointeger(L, 2); + gen_to_be_invoked[key] = (float)LuaAPI.lua_tonumber(L, 3); + LuaAPI.lua_pushboolean(L, true); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __AddMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + UnityEngine.Vector3 leftside;translator.Get(L, 1, out leftside); + UnityEngine.Vector3 rightside;translator.Get(L, 2, out rightside); + + translator.PushUnityEngineVector3(L, leftside + rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of + operator, need UnityEngine.Vector3!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __SubMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + UnityEngine.Vector3 leftside;translator.Get(L, 1, out leftside); + UnityEngine.Vector3 rightside;translator.Get(L, 2, out rightside); + + translator.PushUnityEngineVector3(L, leftside - rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of - operator, need UnityEngine.Vector3!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __UnmMeta(RealStatePtr L) + { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + try { + UnityEngine.Vector3 rightside;translator.Get(L, 1, out rightside); + translator.PushUnityEngineVector3(L, - rightside); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __MulMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + UnityEngine.Vector3 leftside;translator.Get(L, 1, out leftside); + float rightside = (float)LuaAPI.lua_tonumber(L, 2); + + translator.PushUnityEngineVector3(L, leftside * rightside); + + return 1; + } + + + if (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) && translator.Assignable(L, 2)) + { + float leftside = (float)LuaAPI.lua_tonumber(L, 1); + UnityEngine.Vector3 rightside;translator.Get(L, 2, out rightside); + + translator.PushUnityEngineVector3(L, leftside * rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of * operator, need UnityEngine.Vector3!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __DivMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + UnityEngine.Vector3 leftside;translator.Get(L, 1, out leftside); + float rightside = (float)LuaAPI.lua_tonumber(L, 2); + + translator.PushUnityEngineVector3(L, leftside / rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of / operator, need UnityEngine.Vector3!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __EqMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + UnityEngine.Vector3 leftside;translator.Get(L, 1, out leftside); + UnityEngine.Vector3 rightside;translator.Get(L, 2, out rightside); + + LuaAPI.lua_pushboolean(L, leftside == rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of == operator, need UnityEngine.Vector3!"); + + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Lerp_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector3 _a;translator.Get(L, 1, out _a); + UnityEngine.Vector3 _b;translator.Get(L, 2, out _b); + float _t = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Vector3.Lerp( _a, _b, _t ); + translator.PushUnityEngineVector3(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_LerpUnclamped_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector3 _a;translator.Get(L, 1, out _a); + UnityEngine.Vector3 _b;translator.Get(L, 2, out _b); + float _t = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Vector3.LerpUnclamped( _a, _b, _t ); + translator.PushUnityEngineVector3(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_MoveTowards_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector3 _current;translator.Get(L, 1, out _current); + UnityEngine.Vector3 _target;translator.Get(L, 2, out _target); + float _maxDistanceDelta = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Vector3.MoveTowards( _current, _target, _maxDistanceDelta ); + translator.PushUnityEngineVector3(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_SmoothDamp_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 4&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + UnityEngine.Vector3 _current;translator.Get(L, 1, out _current); + UnityEngine.Vector3 _target;translator.Get(L, 2, out _target); + UnityEngine.Vector3 _currentVelocity;translator.Get(L, 3, out _currentVelocity); + float _smoothTime = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = UnityEngine.Vector3.SmoothDamp( _current, _target, ref _currentVelocity, _smoothTime ); + translator.PushUnityEngineVector3(L, gen_ret); + translator.PushUnityEngineVector3(L, _currentVelocity); + translator.UpdateUnityEngineVector3(L, 3, _currentVelocity); + + + + + return 2; + } + if(gen_param_count == 5&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + UnityEngine.Vector3 _current;translator.Get(L, 1, out _current); + UnityEngine.Vector3 _target;translator.Get(L, 2, out _target); + UnityEngine.Vector3 _currentVelocity;translator.Get(L, 3, out _currentVelocity); + float _smoothTime = (float)LuaAPI.lua_tonumber(L, 4); + float _maxSpeed = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = UnityEngine.Vector3.SmoothDamp( _current, _target, ref _currentVelocity, _smoothTime, _maxSpeed ); + translator.PushUnityEngineVector3(L, gen_ret); + translator.PushUnityEngineVector3(L, _currentVelocity); + translator.UpdateUnityEngineVector3(L, 3, _currentVelocity); + + + + + return 2; + } + if(gen_param_count == 6&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 6)) + { + UnityEngine.Vector3 _current;translator.Get(L, 1, out _current); + UnityEngine.Vector3 _target;translator.Get(L, 2, out _target); + UnityEngine.Vector3 _currentVelocity;translator.Get(L, 3, out _currentVelocity); + float _smoothTime = (float)LuaAPI.lua_tonumber(L, 4); + float _maxSpeed = (float)LuaAPI.lua_tonumber(L, 5); + float _deltaTime = (float)LuaAPI.lua_tonumber(L, 6); + + var gen_ret = UnityEngine.Vector3.SmoothDamp( _current, _target, ref _currentVelocity, _smoothTime, _maxSpeed, _deltaTime ); + translator.PushUnityEngineVector3(L, gen_ret); + translator.PushUnityEngineVector3(L, _currentVelocity); + translator.UpdateUnityEngineVector3(L, 3, _currentVelocity); + + + + + return 2; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Vector3.SmoothDamp!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Set(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Vector3 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + float _newX = (float)LuaAPI.lua_tonumber(L, 2); + float _newY = (float)LuaAPI.lua_tonumber(L, 3); + float _newZ = (float)LuaAPI.lua_tonumber(L, 4); + + gen_to_be_invoked.Set( _newX, _newY, _newZ ); + + + translator.UpdateUnityEngineVector3(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Scale_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector3 _a;translator.Get(L, 1, out _a); + UnityEngine.Vector3 _b;translator.Get(L, 2, out _b); + + var gen_ret = UnityEngine.Vector3.Scale( _a, _b ); + translator.PushUnityEngineVector3(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_Scale(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Vector3 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.Vector3 _scale;translator.Get(L, 2, out _scale); + + gen_to_be_invoked.Scale( _scale ); + + + translator.UpdateUnityEngineVector3(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Cross_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector3 _lhs;translator.Get(L, 1, out _lhs); + UnityEngine.Vector3 _rhs;translator.Get(L, 2, out _rhs); + + var gen_ret = UnityEngine.Vector3.Cross( _lhs, _rhs ); + translator.PushUnityEngineVector3(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_GetHashCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Vector3 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.GetHashCode( ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + translator.UpdateUnityEngineVector3(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Equals(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Vector3 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _other = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.Equals( _other ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.UpdateUnityEngineVector3(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _other;translator.Get(L, 2, out _other); + + var gen_ret = gen_to_be_invoked.Equals( _other ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.UpdateUnityEngineVector3(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Vector3.Equals!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Reflect_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector3 _inDirection;translator.Get(L, 1, out _inDirection); + UnityEngine.Vector3 _inNormal;translator.Get(L, 2, out _inNormal); + + var gen_ret = UnityEngine.Vector3.Reflect( _inDirection, _inNormal ); + translator.PushUnityEngineVector3(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_Normalize_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector3 _value;translator.Get(L, 1, out _value); + + var gen_ret = UnityEngine.Vector3.Normalize( _value ); + translator.PushUnityEngineVector3(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_Normalize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Vector3 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + gen_to_be_invoked.Normalize( ); + + + translator.UpdateUnityEngineVector3(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Dot_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector3 _lhs;translator.Get(L, 1, out _lhs); + UnityEngine.Vector3 _rhs;translator.Get(L, 2, out _rhs); + + var gen_ret = UnityEngine.Vector3.Dot( _lhs, _rhs ); + LuaAPI.lua_pushnumber(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_Project_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector3 _vector;translator.Get(L, 1, out _vector); + UnityEngine.Vector3 _onNormal;translator.Get(L, 2, out _onNormal); + + var gen_ret = UnityEngine.Vector3.Project( _vector, _onNormal ); + translator.PushUnityEngineVector3(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_ProjectOnPlane_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector3 _vector;translator.Get(L, 1, out _vector); + UnityEngine.Vector3 _planeNormal;translator.Get(L, 2, out _planeNormal); + + var gen_ret = UnityEngine.Vector3.ProjectOnPlane( _vector, _planeNormal ); + translator.PushUnityEngineVector3(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_Angle_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector3 _from;translator.Get(L, 1, out _from); + UnityEngine.Vector3 _to;translator.Get(L, 2, out _to); + + var gen_ret = UnityEngine.Vector3.Angle( _from, _to ); + LuaAPI.lua_pushnumber(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_SignedAngle_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector3 _from;translator.Get(L, 1, out _from); + UnityEngine.Vector3 _to;translator.Get(L, 2, out _to); + UnityEngine.Vector3 _axis;translator.Get(L, 3, out _axis); + + var gen_ret = UnityEngine.Vector3.SignedAngle( _from, _to, _axis ); + LuaAPI.lua_pushnumber(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_Distance_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector3 _a;translator.Get(L, 1, out _a); + UnityEngine.Vector3 _b;translator.Get(L, 2, out _b); + + var gen_ret = UnityEngine.Vector3.Distance( _a, _b ); + LuaAPI.lua_pushnumber(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_ClampMagnitude_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector3 _vector;translator.Get(L, 1, out _vector); + float _maxLength = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = UnityEngine.Vector3.ClampMagnitude( _vector, _maxLength ); + translator.PushUnityEngineVector3(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_Magnitude_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector3 _vector;translator.Get(L, 1, out _vector); + + var gen_ret = UnityEngine.Vector3.Magnitude( _vector ); + LuaAPI.lua_pushnumber(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_SqrMagnitude_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector3 _vector;translator.Get(L, 1, out _vector); + + var gen_ret = UnityEngine.Vector3.SqrMagnitude( _vector ); + LuaAPI.lua_pushnumber(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_Min_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector3 _lhs;translator.Get(L, 1, out _lhs); + UnityEngine.Vector3 _rhs;translator.Get(L, 2, out _rhs); + + var gen_ret = UnityEngine.Vector3.Min( _lhs, _rhs ); + translator.PushUnityEngineVector3(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_Max_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector3 _lhs;translator.Get(L, 1, out _lhs); + UnityEngine.Vector3 _rhs;translator.Get(L, 2, out _rhs); + + var gen_ret = UnityEngine.Vector3.Max( _lhs, _rhs ); + translator.PushUnityEngineVector3(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_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Vector3 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.ToString( ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.UpdateUnityEngineVector3(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _format = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.ToString( _format ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.UpdateUnityEngineVector3(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _format = LuaAPI.lua_tostring(L, 2); + System.IFormatProvider _formatProvider = (System.IFormatProvider)translator.GetObject(L, 3, typeof(System.IFormatProvider)); + + var gen_ret = gen_to_be_invoked.ToString( _format, _formatProvider ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.UpdateUnityEngineVector3(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Vector3.ToString!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Slerp_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector3 _a;translator.Get(L, 1, out _a); + UnityEngine.Vector3 _b;translator.Get(L, 2, out _b); + float _t = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Vector3.Slerp( _a, _b, _t ); + translator.PushUnityEngineVector3(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_SlerpUnclamped_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector3 _a;translator.Get(L, 1, out _a); + UnityEngine.Vector3 _b;translator.Get(L, 2, out _b); + float _t = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Vector3.SlerpUnclamped( _a, _b, _t ); + translator.PushUnityEngineVector3(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_OrthoNormalize_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)) + { + UnityEngine.Vector3 _normal;translator.Get(L, 1, out _normal); + UnityEngine.Vector3 _tangent;translator.Get(L, 2, out _tangent); + + UnityEngine.Vector3.OrthoNormalize( ref _normal, ref _tangent ); + translator.PushUnityEngineVector3(L, _normal); + translator.UpdateUnityEngineVector3(L, 1, _normal); + + translator.PushUnityEngineVector3(L, _tangent); + translator.UpdateUnityEngineVector3(L, 2, _tangent); + + + + + return 2; + } + if(gen_param_count == 3&& translator.Assignable(L, 1)&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + UnityEngine.Vector3 _normal;translator.Get(L, 1, out _normal); + UnityEngine.Vector3 _tangent;translator.Get(L, 2, out _tangent); + UnityEngine.Vector3 _binormal;translator.Get(L, 3, out _binormal); + + UnityEngine.Vector3.OrthoNormalize( ref _normal, ref _tangent, ref _binormal ); + translator.PushUnityEngineVector3(L, _normal); + translator.UpdateUnityEngineVector3(L, 1, _normal); + + translator.PushUnityEngineVector3(L, _tangent); + translator.UpdateUnityEngineVector3(L, 2, _tangent); + + translator.PushUnityEngineVector3(L, _binormal); + translator.UpdateUnityEngineVector3(L, 3, _binormal); + + + + + return 3; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Vector3.OrthoNormalize!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_RotateTowards_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector3 _current;translator.Get(L, 1, out _current); + UnityEngine.Vector3 _target;translator.Get(L, 2, out _target); + float _maxRadiansDelta = (float)LuaAPI.lua_tonumber(L, 3); + float _maxMagnitudeDelta = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = UnityEngine.Vector3.RotateTowards( _current, _target, _maxRadiansDelta, _maxMagnitudeDelta ); + translator.PushUnityEngineVector3(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_normalized(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Vector3 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector3(L, gen_to_be_invoked.normalized); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_magnitude(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Vector3 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.magnitude); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sqrMagnitude(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Vector3 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.sqrMagnitude); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_zero(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineVector3(L, UnityEngine.Vector3.zero); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_one(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineVector3(L, UnityEngine.Vector3.one); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_forward(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineVector3(L, UnityEngine.Vector3.forward); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_back(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineVector3(L, UnityEngine.Vector3.back); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_up(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineVector3(L, UnityEngine.Vector3.up); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_down(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineVector3(L, UnityEngine.Vector3.down); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_left(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineVector3(L, UnityEngine.Vector3.left); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_right(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineVector3(L, UnityEngine.Vector3.right); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_positiveInfinity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineVector3(L, UnityEngine.Vector3.positiveInfinity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_negativeInfinity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineVector3(L, UnityEngine.Vector3.negativeInfinity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_x(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Vector3 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.x); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_y(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Vector3 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.y); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_z(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Vector3 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.z); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_x(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Vector3 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.x = (float)LuaAPI.lua_tonumber(L, 2); + + translator.UpdateUnityEngineVector3(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_y(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Vector3 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.y = (float)LuaAPI.lua_tonumber(L, 2); + + translator.UpdateUnityEngineVector3(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_z(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Vector3 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.z = (float)LuaAPI.lua_tonumber(L, 2); + + translator.UpdateUnityEngineVector3(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_Vector4Wrap.cs b/Assets/XLua/Gen/UnityEngine_Vector4Wrap.cs new file mode 100644 index 000000000..9b38ee557 --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_Vector4Wrap.cs @@ -0,0 +1,1174 @@ +#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 UnityEngineVector4Wrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Vector4); + Utils.BeginObjectRegister(type, L, translator, 6, 7, 7, 4); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__add", __AddMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__sub", __SubMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__unm", __UnmMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__mul", __MulMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__div", __DivMeta); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__eq", __EqMeta); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Set", _m_Set); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Scale", _m_Scale); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashCode", _m_GetHashCode); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Equals", _m_Equals); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Normalize", _m_Normalize); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SqrMagnitude", _m_SqrMagnitude); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "normalized", _g_get_normalized); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "magnitude", _g_get_magnitude); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sqrMagnitude", _g_get_sqrMagnitude); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "x", _g_get_x); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "y", _g_get_y); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "z", _g_get_z); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "w", _g_get_w); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "x", _s_set_x); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "y", _s_set_y); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "z", _s_set_z); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "w", _s_set_w); + + + Utils.EndObjectRegister(type, L, translator, __CSIndexer, __NewIndexer, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 14, 4, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Lerp", _m_Lerp_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LerpUnclamped", _m_LerpUnclamped_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "MoveTowards", _m_MoveTowards_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Scale", _m_Scale_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Normalize", _m_Normalize_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Dot", _m_Dot_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Project", _m_Project_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Distance", _m_Distance_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Magnitude", _m_Magnitude_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Min", _m_Min_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Max", _m_Max_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SqrMagnitude", _m_SqrMagnitude_xlua_st_); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "kEpsilon", UnityEngine.Vector4.kEpsilon); + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "zero", _g_get_zero); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "one", _g_get_one); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "positiveInfinity", _g_get_positiveInfinity); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "negativeInfinity", _g_get_negativeInfinity); + + + + 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) == 5 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 5)) + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + float _w = (float)LuaAPI.lua_tonumber(L, 5); + + var gen_ret = new UnityEngine.Vector4(_x, _y, _z, _w); + translator.PushUnityEngineVector4(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 4 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + float _z = (float)LuaAPI.lua_tonumber(L, 4); + + var gen_ret = new UnityEngine.Vector4(_x, _y, _z); + translator.PushUnityEngineVector4(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 3 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + float _x = (float)LuaAPI.lua_tonumber(L, 2); + float _y = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = new UnityEngine.Vector4(_x, _y); + translator.PushUnityEngineVector4(L, gen_ret); + + return 1; + } + + if (LuaAPI.lua_gettop(L) == 1) + { + translator.PushUnityEngineVector4(L, default(UnityEngine.Vector4)); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Vector4 constructor!"); + + } + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __CSIndexer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + if (translator.Assignable(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + + UnityEngine.Vector4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + int index = LuaAPI.xlua_tointeger(L, 2); + LuaAPI.lua_pushboolean(L, true); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked[index]); + return 2; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __NewIndexer(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + try { + + if (translator.Assignable(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) + { + + UnityEngine.Vector4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + int key = LuaAPI.xlua_tointeger(L, 2); + gen_to_be_invoked[key] = (float)LuaAPI.lua_tonumber(L, 3); + LuaAPI.lua_pushboolean(L, true); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __AddMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + UnityEngine.Vector4 leftside;translator.Get(L, 1, out leftside); + UnityEngine.Vector4 rightside;translator.Get(L, 2, out rightside); + + translator.PushUnityEngineVector4(L, leftside + rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of + operator, need UnityEngine.Vector4!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __SubMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + UnityEngine.Vector4 leftside;translator.Get(L, 1, out leftside); + UnityEngine.Vector4 rightside;translator.Get(L, 2, out rightside); + + translator.PushUnityEngineVector4(L, leftside - rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of - operator, need UnityEngine.Vector4!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __UnmMeta(RealStatePtr L) + { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + try { + UnityEngine.Vector4 rightside;translator.Get(L, 1, out rightside); + translator.PushUnityEngineVector4(L, - rightside); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __MulMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + UnityEngine.Vector4 leftside;translator.Get(L, 1, out leftside); + float rightside = (float)LuaAPI.lua_tonumber(L, 2); + + translator.PushUnityEngineVector4(L, leftside * rightside); + + return 1; + } + + + if (LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1) && translator.Assignable(L, 2)) + { + float leftside = (float)LuaAPI.lua_tonumber(L, 1); + UnityEngine.Vector4 rightside;translator.Get(L, 2, out rightside); + + translator.PushUnityEngineVector4(L, leftside * rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of * operator, need UnityEngine.Vector4!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __DivMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + UnityEngine.Vector4 leftside;translator.Get(L, 1, out leftside); + float rightside = (float)LuaAPI.lua_tonumber(L, 2); + + translator.PushUnityEngineVector4(L, leftside / rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of / operator, need UnityEngine.Vector4!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __EqMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + UnityEngine.Vector4 leftside;translator.Get(L, 1, out leftside); + UnityEngine.Vector4 rightside;translator.Get(L, 2, out rightside); + + LuaAPI.lua_pushboolean(L, leftside == rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of == operator, need UnityEngine.Vector4!"); + + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Set(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Vector4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + float _newX = (float)LuaAPI.lua_tonumber(L, 2); + float _newY = (float)LuaAPI.lua_tonumber(L, 3); + float _newZ = (float)LuaAPI.lua_tonumber(L, 4); + float _newW = (float)LuaAPI.lua_tonumber(L, 5); + + gen_to_be_invoked.Set( _newX, _newY, _newZ, _newW ); + + + translator.UpdateUnityEngineVector4(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Lerp_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector4 _a;translator.Get(L, 1, out _a); + UnityEngine.Vector4 _b;translator.Get(L, 2, out _b); + float _t = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Vector4.Lerp( _a, _b, _t ); + translator.PushUnityEngineVector4(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_LerpUnclamped_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector4 _a;translator.Get(L, 1, out _a); + UnityEngine.Vector4 _b;translator.Get(L, 2, out _b); + float _t = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Vector4.LerpUnclamped( _a, _b, _t ); + translator.PushUnityEngineVector4(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_MoveTowards_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector4 _current;translator.Get(L, 1, out _current); + UnityEngine.Vector4 _target;translator.Get(L, 2, out _target); + float _maxDistanceDelta = (float)LuaAPI.lua_tonumber(L, 3); + + var gen_ret = UnityEngine.Vector4.MoveTowards( _current, _target, _maxDistanceDelta ); + translator.PushUnityEngineVector4(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_Scale_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector4 _a;translator.Get(L, 1, out _a); + UnityEngine.Vector4 _b;translator.Get(L, 2, out _b); + + var gen_ret = UnityEngine.Vector4.Scale( _a, _b ); + translator.PushUnityEngineVector4(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_Scale(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Vector4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + UnityEngine.Vector4 _scale;translator.Get(L, 2, out _scale); + + gen_to_be_invoked.Scale( _scale ); + + + translator.UpdateUnityEngineVector4(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetHashCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Vector4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.GetHashCode( ); + LuaAPI.xlua_pushinteger(L, gen_ret); + + + translator.UpdateUnityEngineVector4(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Equals(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Vector4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + object _other = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.Equals( _other ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.UpdateUnityEngineVector4(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + UnityEngine.Vector4 _other;translator.Get(L, 2, out _other); + + var gen_ret = gen_to_be_invoked.Equals( _other ); + LuaAPI.lua_pushboolean(L, gen_ret); + + + translator.UpdateUnityEngineVector4(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Vector4.Equals!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Normalize_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector4 _a;translator.Get(L, 1, out _a); + + var gen_ret = UnityEngine.Vector4.Normalize( _a ); + translator.PushUnityEngineVector4(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_Normalize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Vector4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + gen_to_be_invoked.Normalize( ); + + + translator.UpdateUnityEngineVector4(L, 1, gen_to_be_invoked); + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Dot_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector4 _a;translator.Get(L, 1, out _a); + UnityEngine.Vector4 _b;translator.Get(L, 2, out _b); + + var gen_ret = UnityEngine.Vector4.Dot( _a, _b ); + LuaAPI.lua_pushnumber(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_Project_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector4 _a;translator.Get(L, 1, out _a); + UnityEngine.Vector4 _b;translator.Get(L, 2, out _b); + + var gen_ret = UnityEngine.Vector4.Project( _a, _b ); + translator.PushUnityEngineVector4(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_Distance_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector4 _a;translator.Get(L, 1, out _a); + UnityEngine.Vector4 _b;translator.Get(L, 2, out _b); + + var gen_ret = UnityEngine.Vector4.Distance( _a, _b ); + LuaAPI.lua_pushnumber(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_Magnitude_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector4 _a;translator.Get(L, 1, out _a); + + var gen_ret = UnityEngine.Vector4.Magnitude( _a ); + LuaAPI.lua_pushnumber(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_Min_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector4 _lhs;translator.Get(L, 1, out _lhs); + UnityEngine.Vector4 _rhs;translator.Get(L, 2, out _rhs); + + var gen_ret = UnityEngine.Vector4.Min( _lhs, _rhs ); + translator.PushUnityEngineVector4(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_Max_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector4 _lhs;translator.Get(L, 1, out _lhs); + UnityEngine.Vector4 _rhs;translator.Get(L, 2, out _rhs); + + var gen_ret = UnityEngine.Vector4.Max( _lhs, _rhs ); + translator.PushUnityEngineVector4(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_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Vector4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.ToString( ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.UpdateUnityEngineVector4(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _format = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.ToString( _format ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.UpdateUnityEngineVector4(L, 1, gen_to_be_invoked); + + + return 1; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _format = LuaAPI.lua_tostring(L, 2); + System.IFormatProvider _formatProvider = (System.IFormatProvider)translator.GetObject(L, 3, typeof(System.IFormatProvider)); + + var gen_ret = gen_to_be_invoked.ToString( _format, _formatProvider ); + LuaAPI.lua_pushstring(L, gen_ret); + + + translator.UpdateUnityEngineVector4(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Vector4.ToString!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SqrMagnitude_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + UnityEngine.Vector4 _a;translator.Get(L, 1, out _a); + + var gen_ret = UnityEngine.Vector4.SqrMagnitude( _a ); + LuaAPI.lua_pushnumber(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_SqrMagnitude(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Vector4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + + + + { + + var gen_ret = gen_to_be_invoked.SqrMagnitude( ); + LuaAPI.lua_pushnumber(L, gen_ret); + + + translator.UpdateUnityEngineVector4(L, 1, gen_to_be_invoked); + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_normalized(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Vector4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + translator.PushUnityEngineVector4(L, gen_to_be_invoked.normalized); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_magnitude(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Vector4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.magnitude); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sqrMagnitude(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Vector4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.sqrMagnitude); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_zero(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineVector4(L, UnityEngine.Vector4.zero); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_one(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineVector4(L, UnityEngine.Vector4.one); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_positiveInfinity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineVector4(L, UnityEngine.Vector4.positiveInfinity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_negativeInfinity(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.PushUnityEngineVector4(L, UnityEngine.Vector4.negativeInfinity); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_x(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Vector4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.x); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_y(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Vector4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.y); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_z(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Vector4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.z); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_w(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Vector4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.w); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_x(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Vector4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.x = (float)LuaAPI.lua_tonumber(L, 2); + + translator.UpdateUnityEngineVector4(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_y(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Vector4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.y = (float)LuaAPI.lua_tonumber(L, 2); + + translator.UpdateUnityEngineVector4(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_z(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Vector4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.z = (float)LuaAPI.lua_tonumber(L, 2); + + translator.UpdateUnityEngineVector4(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_w(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Vector4 gen_to_be_invoked;translator.Get(L, 1, out gen_to_be_invoked); + gen_to_be_invoked.w = (float)LuaAPI.lua_tonumber(L, 2); + + translator.UpdateUnityEngineVector4(L, 1, gen_to_be_invoked); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_Video_VideoClipWrap.cs b/Assets/XLua/Gen/UnityEngine_Video_VideoClipWrap.cs new file mode 100644 index 000000000..de469948d --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_Video_VideoClipWrap.cs @@ -0,0 +1,307 @@ +#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 UnityEngineVideoVideoClipWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Video.VideoClip); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 10, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAudioChannelCount", _m_GetAudioChannelCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAudioSampleRate", _m_GetAudioSampleRate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAudioLanguage", _m_GetAudioLanguage); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "originalPath", _g_get_originalPath); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "frameCount", _g_get_frameCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "frameRate", _g_get_frameRate); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "length", _g_get_length); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "width", _g_get_width); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "height", _g_get_height); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "pixelAspectRatioNumerator", _g_get_pixelAspectRatioNumerator); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "pixelAspectRatioDenominator", _g_get_pixelAspectRatioDenominator); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sRGB", _g_get_sRGB); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "audioTrackCount", _g_get_audioTrackCount); + + + + 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, "UnityEngine.Video.VideoClip does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetAudioChannelCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Video.VideoClip gen_to_be_invoked = (UnityEngine.Video.VideoClip)translator.FastGetCSObj(L, 1); + + + + { + ushort _audioTrackIdx = (ushort)LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetAudioChannelCount( _audioTrackIdx ); + 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_GetAudioSampleRate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Video.VideoClip gen_to_be_invoked = (UnityEngine.Video.VideoClip)translator.FastGetCSObj(L, 1); + + + + { + ushort _audioTrackIdx = (ushort)LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetAudioSampleRate( _audioTrackIdx ); + LuaAPI.xlua_pushuint(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_GetAudioLanguage(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Video.VideoClip gen_to_be_invoked = (UnityEngine.Video.VideoClip)translator.FastGetCSObj(L, 1); + + + + { + ushort _audioTrackIdx = (ushort)LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetAudioLanguage( _audioTrackIdx ); + 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_originalPath(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoClip gen_to_be_invoked = (UnityEngine.Video.VideoClip)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.originalPath); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_frameCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoClip gen_to_be_invoked = (UnityEngine.Video.VideoClip)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushuint64(L, gen_to_be_invoked.frameCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_frameRate(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoClip gen_to_be_invoked = (UnityEngine.Video.VideoClip)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.frameRate); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_length(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoClip gen_to_be_invoked = (UnityEngine.Video.VideoClip)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.length); + } 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); + + UnityEngine.Video.VideoClip gen_to_be_invoked = (UnityEngine.Video.VideoClip)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushuint(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); + + UnityEngine.Video.VideoClip gen_to_be_invoked = (UnityEngine.Video.VideoClip)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushuint(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 _g_get_pixelAspectRatioNumerator(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoClip gen_to_be_invoked = (UnityEngine.Video.VideoClip)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushuint(L, gen_to_be_invoked.pixelAspectRatioNumerator); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_pixelAspectRatioDenominator(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoClip gen_to_be_invoked = (UnityEngine.Video.VideoClip)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushuint(L, gen_to_be_invoked.pixelAspectRatioDenominator); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sRGB(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoClip gen_to_be_invoked = (UnityEngine.Video.VideoClip)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.sRGB); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_audioTrackCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoClip gen_to_be_invoked = (UnityEngine.Video.VideoClip)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.audioTrackCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UnityEngine_Video_VideoPlayerWrap.cs b/Assets/XLua/Gen/UnityEngine_Video_VideoPlayerWrap.cs new file mode 100644 index 000000000..a87d6cd0d --- /dev/null +++ b/Assets/XLua/Gen/UnityEngine_Video_VideoPlayerWrap.cs @@ -0,0 +1,1883 @@ +#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 UnityEngineVideoVideoPlayerWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnityEngine.Video.VideoPlayer); + Utils.BeginObjectRegister(type, L, translator, 0, 24, 43, 24); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Prepare", _m_Prepare); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Play", _m_Play); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Pause", _m_Pause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Stop", _m_Stop); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "StepForward", _m_StepForward); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAudioLanguageCode", _m_GetAudioLanguageCode); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAudioChannelCount", _m_GetAudioChannelCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAudioSampleRate", _m_GetAudioSampleRate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "EnableAudioTrack", _m_EnableAudioTrack); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsAudioTrackEnabled", _m_IsAudioTrackEnabled); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetDirectAudioVolume", _m_GetDirectAudioVolume); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetDirectAudioVolume", _m_SetDirectAudioVolume); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetDirectAudioMute", _m_GetDirectAudioMute); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetDirectAudioMute", _m_SetDirectAudioMute); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTargetAudioSource", _m_GetTargetAudioSource); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTargetAudioSource", _m_SetTargetAudioSource); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "prepareCompleted", _e_prepareCompleted); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "loopPointReached", _e_loopPointReached); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "started", _e_started); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "frameDropped", _e_frameDropped); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "errorReceived", _e_errorReceived); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "seekCompleted", _e_seekCompleted); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "clockResyncOccurred", _e_clockResyncOccurred); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "frameReady", _e_frameReady); + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "source", _g_get_source); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "url", _g_get_url); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "clip", _g_get_clip); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "renderMode", _g_get_renderMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "targetCamera", _g_get_targetCamera); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "targetTexture", _g_get_targetTexture); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "targetMaterialRenderer", _g_get_targetMaterialRenderer); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "targetMaterialProperty", _g_get_targetMaterialProperty); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "aspectRatio", _g_get_aspectRatio); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "targetCameraAlpha", _g_get_targetCameraAlpha); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "targetCamera3DLayout", _g_get_targetCamera3DLayout); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "texture", _g_get_texture); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isPrepared", _g_get_isPrepared); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "waitForFirstFrame", _g_get_waitForFirstFrame); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "playOnAwake", _g_get_playOnAwake); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isPlaying", _g_get_isPlaying); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isPaused", _g_get_isPaused); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "canSetTime", _g_get_canSetTime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "time", _g_get_time); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "frame", _g_get_frame); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "clockTime", _g_get_clockTime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "canStep", _g_get_canStep); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "canSetPlaybackSpeed", _g_get_canSetPlaybackSpeed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "playbackSpeed", _g_get_playbackSpeed); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "isLooping", _g_get_isLooping); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "canSetTimeSource", _g_get_canSetTimeSource); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "timeSource", _g_get_timeSource); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "timeReference", _g_get_timeReference); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "externalReferenceTime", _g_get_externalReferenceTime); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "canSetSkipOnDrop", _g_get_canSetSkipOnDrop); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "skipOnDrop", _g_get_skipOnDrop); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "frameCount", _g_get_frameCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "frameRate", _g_get_frameRate); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "length", _g_get_length); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "width", _g_get_width); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "height", _g_get_height); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "pixelAspectRatioNumerator", _g_get_pixelAspectRatioNumerator); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "pixelAspectRatioDenominator", _g_get_pixelAspectRatioDenominator); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "audioTrackCount", _g_get_audioTrackCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "controlledAudioTrackCount", _g_get_controlledAudioTrackCount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "audioOutputMode", _g_get_audioOutputMode); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "canSetDirectAudioVolume", _g_get_canSetDirectAudioVolume); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sendFrameReadyEvents", _g_get_sendFrameReadyEvents); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "source", _s_set_source); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "url", _s_set_url); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "clip", _s_set_clip); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "renderMode", _s_set_renderMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "targetCamera", _s_set_targetCamera); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "targetTexture", _s_set_targetTexture); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "targetMaterialRenderer", _s_set_targetMaterialRenderer); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "targetMaterialProperty", _s_set_targetMaterialProperty); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "aspectRatio", _s_set_aspectRatio); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "targetCameraAlpha", _s_set_targetCameraAlpha); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "targetCamera3DLayout", _s_set_targetCamera3DLayout); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "waitForFirstFrame", _s_set_waitForFirstFrame); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "playOnAwake", _s_set_playOnAwake); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "time", _s_set_time); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "frame", _s_set_frame); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "playbackSpeed", _s_set_playbackSpeed); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "isLooping", _s_set_isLooping); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "timeSource", _s_set_timeSource); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "timeReference", _s_set_timeReference); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "externalReferenceTime", _s_set_externalReferenceTime); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "skipOnDrop", _s_set_skipOnDrop); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "controlledAudioTrackCount", _s_set_controlledAudioTrackCount); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "audioOutputMode", _s_set_audioOutputMode); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sendFrameReadyEvents", _s_set_sendFrameReadyEvents); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 1, 0); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "controlledAudioTrackMaxCount", _g_get_controlledAudioTrackMaxCount); + + + + 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 UnityEngine.Video.VideoPlayer(); + 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 UnityEngine.Video.VideoPlayer constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Prepare(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Prepare( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Play(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Play( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Pause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Pause( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Stop(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.Stop( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_StepForward(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.StepForward( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetAudioLanguageCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + + + + { + ushort _trackIndex = (ushort)LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetAudioLanguageCode( _trackIndex ); + 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 _m_GetAudioChannelCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + + + + { + ushort _trackIndex = (ushort)LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetAudioChannelCount( _trackIndex ); + 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_GetAudioSampleRate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + + + + { + ushort _trackIndex = (ushort)LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetAudioSampleRate( _trackIndex ); + LuaAPI.xlua_pushuint(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_EnableAudioTrack(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + + + + { + ushort _trackIndex = (ushort)LuaAPI.xlua_tointeger(L, 2); + bool _enabled = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.EnableAudioTrack( _trackIndex, _enabled ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_IsAudioTrackEnabled(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + + + + { + ushort _trackIndex = (ushort)LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.IsAudioTrackEnabled( _trackIndex ); + 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_GetDirectAudioVolume(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + + + + { + ushort _trackIndex = (ushort)LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetDirectAudioVolume( _trackIndex ); + LuaAPI.lua_pushnumber(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_SetDirectAudioVolume(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + + + + { + ushort _trackIndex = (ushort)LuaAPI.xlua_tointeger(L, 2); + float _volume = (float)LuaAPI.lua_tonumber(L, 3); + + gen_to_be_invoked.SetDirectAudioVolume( _trackIndex, _volume ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetDirectAudioMute(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + + + + { + ushort _trackIndex = (ushort)LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetDirectAudioMute( _trackIndex ); + 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_SetDirectAudioMute(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + + + + { + ushort _trackIndex = (ushort)LuaAPI.xlua_tointeger(L, 2); + bool _mute = LuaAPI.lua_toboolean(L, 3); + + gen_to_be_invoked.SetDirectAudioMute( _trackIndex, _mute ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetTargetAudioSource(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + + + + { + ushort _trackIndex = (ushort)LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.GetTargetAudioSource( _trackIndex ); + 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_SetTargetAudioSource(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + + + + { + ushort _trackIndex = (ushort)LuaAPI.xlua_tointeger(L, 2); + UnityEngine.AudioSource _source = (UnityEngine.AudioSource)translator.GetObject(L, 3, typeof(UnityEngine.AudioSource)); + + gen_to_be_invoked.SetTargetAudioSource( _trackIndex, _source ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_source(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.source); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_url(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.url); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_clip(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.clip); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_renderMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.renderMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_targetCamera(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.targetCamera); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_targetTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.targetTexture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_targetMaterialRenderer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.targetMaterialRenderer); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_targetMaterialProperty(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.targetMaterialProperty); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_aspectRatio(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.aspectRatio); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_targetCameraAlpha(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.targetCameraAlpha); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_targetCamera3DLayout(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.targetCamera3DLayout); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_texture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.texture); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isPrepared(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isPrepared); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_waitForFirstFrame(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.waitForFirstFrame); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_playOnAwake(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.playOnAwake); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isPlaying(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isPlaying); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isPaused(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isPaused); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_canSetTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.canSetTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_time(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.time); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_frame(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushint64(L, gen_to_be_invoked.frame); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_clockTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.clockTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_canStep(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.canStep); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_canSetPlaybackSpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.canSetPlaybackSpeed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_playbackSpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.playbackSpeed); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_isLooping(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isLooping); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_canSetTimeSource(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.canSetTimeSource); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_timeSource(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.timeSource); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_timeReference(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.timeReference); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_externalReferenceTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.externalReferenceTime); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_canSetSkipOnDrop(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.canSetSkipOnDrop); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_skipOnDrop(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.skipOnDrop); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_frameCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushuint64(L, gen_to_be_invoked.frameCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_frameRate(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.frameRate); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_length(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.length); + } 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); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushuint(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); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushuint(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 _g_get_pixelAspectRatioNumerator(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushuint(L, gen_to_be_invoked.pixelAspectRatioNumerator); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_pixelAspectRatioDenominator(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushuint(L, gen_to_be_invoked.pixelAspectRatioDenominator); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_audioTrackCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.audioTrackCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_controlledAudioTrackMaxCount(RealStatePtr L) + { + try { + + LuaAPI.xlua_pushinteger(L, UnityEngine.Video.VideoPlayer.controlledAudioTrackMaxCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_controlledAudioTrackCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.controlledAudioTrackCount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_audioOutputMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.audioOutputMode); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_canSetDirectAudioVolume(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.canSetDirectAudioVolume); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sendFrameReadyEvents(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.sendFrameReadyEvents); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_source(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + UnityEngine.Video.VideoSource gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.source = 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_url(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.url = 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_clip(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.clip = (UnityEngine.Video.VideoClip)translator.GetObject(L, 2, typeof(UnityEngine.Video.VideoClip)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_renderMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + UnityEngine.Video.VideoRenderMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.renderMode = 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_targetCamera(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.targetCamera = (UnityEngine.Camera)translator.GetObject(L, 2, typeof(UnityEngine.Camera)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_targetTexture(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.targetTexture = (UnityEngine.RenderTexture)translator.GetObject(L, 2, typeof(UnityEngine.RenderTexture)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_targetMaterialRenderer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.targetMaterialRenderer = (UnityEngine.Renderer)translator.GetObject(L, 2, typeof(UnityEngine.Renderer)); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_targetMaterialProperty(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.targetMaterialProperty = 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_aspectRatio(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + UnityEngine.Video.VideoAspectRatio gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.aspectRatio = 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_targetCameraAlpha(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.targetCameraAlpha = (float)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_targetCamera3DLayout(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + UnityEngine.Video.Video3DLayout gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.targetCamera3DLayout = 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_waitForFirstFrame(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.waitForFirstFrame = 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_playOnAwake(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.playOnAwake = 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_time(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.time = 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_frame(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.frame = 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_playbackSpeed(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.playbackSpeed = (float)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_isLooping(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.isLooping = 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_timeSource(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + UnityEngine.Video.VideoTimeSource gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.timeSource = 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_timeReference(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + UnityEngine.Video.VideoTimeReference gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.timeReference = 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_externalReferenceTime(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.externalReferenceTime = 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_skipOnDrop(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.skipOnDrop = 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_controlledAudioTrackCount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.controlledAudioTrackCount = (ushort)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_audioOutputMode(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + UnityEngine.Video.VideoAudioOutputMode gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.audioOutputMode = 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_sendFrameReadyEvents(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.sendFrameReadyEvents = 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 _e_prepareCompleted(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + UnityEngine.Video.VideoPlayer.EventHandler gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need UnityEngine.Video.VideoPlayer.EventHandler!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.prepareCompleted += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.prepareCompleted -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Video.VideoPlayer.prepareCompleted!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_loopPointReached(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + UnityEngine.Video.VideoPlayer.EventHandler gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need UnityEngine.Video.VideoPlayer.EventHandler!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.loopPointReached += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.loopPointReached -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Video.VideoPlayer.loopPointReached!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_started(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + UnityEngine.Video.VideoPlayer.EventHandler gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need UnityEngine.Video.VideoPlayer.EventHandler!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.started += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.started -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Video.VideoPlayer.started!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_frameDropped(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + UnityEngine.Video.VideoPlayer.EventHandler gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need UnityEngine.Video.VideoPlayer.EventHandler!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.frameDropped += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.frameDropped -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Video.VideoPlayer.frameDropped!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_errorReceived(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + UnityEngine.Video.VideoPlayer.ErrorEventHandler gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need UnityEngine.Video.VideoPlayer.ErrorEventHandler!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.errorReceived += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.errorReceived -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Video.VideoPlayer.errorReceived!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_seekCompleted(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + UnityEngine.Video.VideoPlayer.EventHandler gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need UnityEngine.Video.VideoPlayer.EventHandler!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.seekCompleted += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.seekCompleted -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Video.VideoPlayer.seekCompleted!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_clockResyncOccurred(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + UnityEngine.Video.VideoPlayer.TimeEventHandler gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need UnityEngine.Video.VideoPlayer.TimeEventHandler!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.clockResyncOccurred += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.clockResyncOccurred -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Video.VideoPlayer.clockResyncOccurred!"); + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _e_frameReady(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + int gen_param_count = LuaAPI.lua_gettop(L); + UnityEngine.Video.VideoPlayer gen_to_be_invoked = (UnityEngine.Video.VideoPlayer)translator.FastGetCSObj(L, 1); + UnityEngine.Video.VideoPlayer.FrameReadyEventHandler gen_delegate = translator.GetDelegate(L, 3); + if (gen_delegate == null) { + return LuaAPI.luaL_error(L, "#3 need UnityEngine.Video.VideoPlayer.FrameReadyEventHandler!"); + } + + if (gen_param_count == 3) + { + + if (LuaAPI.xlua_is_eq_str(L, 2, "+")) { + gen_to_be_invoked.frameReady += gen_delegate; + return 0; + } + + + if (LuaAPI.xlua_is_eq_str(L, 2, "-")) { + gen_to_be_invoked.frameReady -= gen_delegate; + return 0; + } + + } + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + LuaAPI.luaL_error(L, "invalid arguments to UnityEngine.Video.VideoPlayer.frameReady!"); + return 0; + } + + + + } +} diff --git a/Assets/XLua/Gen/UnsupportedPlatformAgentWrap.cs b/Assets/XLua/Gen/UnsupportedPlatformAgentWrap.cs new file mode 100644 index 000000000..3bc3225db --- /dev/null +++ b/Assets/XLua/Gen/UnsupportedPlatformAgentWrap.cs @@ -0,0 +1,1535 @@ +#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 UnsupportedPlatformAgentWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UnsupportedPlatformAgent); + Utils.BeginObjectRegister(type, L, translator, 0, 47, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetWaterfallConfiguration", _m_SetWaterfallConfiguration); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "start", _m_start); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "onApplicationPause", _m_onApplicationPause); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "getAdvertiserId", _m_getAdvertiserId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "validateIntegration", _m_validateIntegration); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "shouldTrackNetworkState", _m_shouldTrackNetworkState); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setDynamicUserId", _m_setDynamicUserId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setAdaptersDebug", _m_setAdaptersDebug); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setMetaData", _m_setMetaData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "getConversionValue", _m_getConversionValue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setManualLoadRewardedVideo", _m_setManualLoadRewardedVideo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setNetworkData", _m_setNetworkData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPauseGame", _m_SetPauseGame); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setUserId", _m_setUserId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "init", _m_init); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "initISDemandOnly", _m_initISDemandOnly); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "loadRewardedVideo", _m_loadRewardedVideo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "showRewardedVideo", _m_showRewardedVideo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "isRewardedVideoAvailable", _m_isRewardedVideoAvailable); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "isRewardedVideoPlacementCapped", _m_isRewardedVideoPlacementCapped); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "getPlacementInfo", _m_getPlacementInfo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setRewardedVideoServerParams", _m_setRewardedVideoServerParams); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "clearRewardedVideoServerParams", _m_clearRewardedVideoServerParams); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "showISDemandOnlyRewardedVideo", _m_showISDemandOnlyRewardedVideo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "loadISDemandOnlyRewardedVideo", _m_loadISDemandOnlyRewardedVideo); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "isISDemandOnlyRewardedVideoAvailable", _m_isISDemandOnlyRewardedVideoAvailable); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "loadInterstitial", _m_loadInterstitial); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "showInterstitial", _m_showInterstitial); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "isInterstitialReady", _m_isInterstitialReady); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "isInterstitialPlacementCapped", _m_isInterstitialPlacementCapped); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "loadISDemandOnlyInterstitial", _m_loadISDemandOnlyInterstitial); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "showISDemandOnlyInterstitial", _m_showISDemandOnlyInterstitial); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "isISDemandOnlyInterstitialReady", _m_isISDemandOnlyInterstitialReady); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "showOfferwall", _m_showOfferwall); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "getOfferwallCredits", _m_getOfferwallCredits); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "isOfferwallAvailable", _m_isOfferwallAvailable); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "loadBanner", _m_loadBanner); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "destroyBanner", _m_destroyBanner); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "displayBanner", _m_displayBanner); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "hideBanner", _m_hideBanner); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "isBannerPlacementCapped", _m_isBannerPlacementCapped); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setSegment", _m_setSegment); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setConsent", _m_setConsent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "loadConsentViewWithType", _m_loadConsentViewWithType); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "showConsentViewWithType", _m_showConsentViewWithType); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setAdRevenueData", _m_setAdRevenueData); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "launchTestSuite", _m_launchTestSuite); + + + + + + 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 UnsupportedPlatformAgent(); + 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 UnsupportedPlatformAgent constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetWaterfallConfiguration(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + WaterfallConfiguration _waterfallConfiguration = (WaterfallConfiguration)translator.GetObject(L, 2, typeof(WaterfallConfiguration)); + AdFormat _adFormat;translator.Get(L, 3, out _adFormat); + + gen_to_be_invoked.SetWaterfallConfiguration( _waterfallConfiguration, _adFormat ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_start(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.start( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_onApplicationPause(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + bool _pause = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.onApplicationPause( _pause ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_getAdvertiserId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.getAdvertiserId( ); + 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 _m_validateIntegration(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.validateIntegration( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_shouldTrackNetworkState(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + bool _track = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.shouldTrackNetworkState( _track ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setDynamicUserId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + string _dynamicUserId = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.setDynamicUserId( _dynamicUserId ); + 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_setAdaptersDebug(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + bool _enabled = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.setAdaptersDebug( _enabled ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setMetaData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 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); + + gen_to_be_invoked.setMetaData( _key, _value ); + + + + return 0; + } + if(gen_param_count >= 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 3) || (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING))) + { + string _key = LuaAPI.lua_tostring(L, 2); + string[] _values = translator.GetParams(L, 3); + + gen_to_be_invoked.setMetaData( _key, _values ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnsupportedPlatformAgent.setMetaData!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_getConversionValue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.getConversionValue( ); + 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_setManualLoadRewardedVideo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + bool _isOn = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.setManualLoadRewardedVideo( _isOn ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setNetworkData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + string _networkKey = LuaAPI.lua_tostring(L, 2); + string _networkDataJson = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.setNetworkData( _networkKey, _networkDataJson ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetPauseGame(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + bool _pause = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.SetPauseGame( _pause ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setUserId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + string _userId = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.setUserId( _userId ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_init(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _appKey = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.init( _appKey ); + + + + return 0; + } + if(gen_param_count >= 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 3) || (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING))) + { + string _appKey = LuaAPI.lua_tostring(L, 2); + string[] _adUnits = translator.GetParams(L, 3); + + gen_to_be_invoked.init( _appKey, _adUnits ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnsupportedPlatformAgent.init!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_initISDemandOnly(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + string _appKey = LuaAPI.lua_tostring(L, 2); + string[] _adUnits = translator.GetParams(L, 3); + + gen_to_be_invoked.initISDemandOnly( _appKey, _adUnits ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_loadRewardedVideo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.loadRewardedVideo( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_showRewardedVideo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.showRewardedVideo( ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _placementName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.showRewardedVideo( _placementName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnsupportedPlatformAgent.showRewardedVideo!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_isRewardedVideoAvailable(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.isRewardedVideoAvailable( ); + 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_isRewardedVideoPlacementCapped(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + string _placementName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.isRewardedVideoPlacementCapped( _placementName ); + 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_getPlacementInfo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + string _placementName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.getPlacementInfo( _placementName ); + 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_setRewardedVideoServerParams(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + System.Collections.Generic.Dictionary _parameters = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + + gen_to_be_invoked.setRewardedVideoServerParams( _parameters ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_clearRewardedVideoServerParams(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.clearRewardedVideoServerParams( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_showISDemandOnlyRewardedVideo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + string _instanceId = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.showISDemandOnlyRewardedVideo( _instanceId ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_loadISDemandOnlyRewardedVideo(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + string _instanceId = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.loadISDemandOnlyRewardedVideo( _instanceId ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_isISDemandOnlyRewardedVideoAvailable(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + string _instanceId = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.isISDemandOnlyRewardedVideoAvailable( _instanceId ); + 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_loadInterstitial(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.loadInterstitial( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_showInterstitial(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.showInterstitial( ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _placementName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.showInterstitial( _placementName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnsupportedPlatformAgent.showInterstitial!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_isInterstitialReady(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.isInterstitialReady( ); + 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_isInterstitialPlacementCapped(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + string _placementName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.isInterstitialPlacementCapped( _placementName ); + 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_loadISDemandOnlyInterstitial(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + string _instanceId = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.loadISDemandOnlyInterstitial( _instanceId ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_showISDemandOnlyInterstitial(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + string _instanceId = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.showISDemandOnlyInterstitial( _instanceId ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_isISDemandOnlyInterstitialReady(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + string _instanceId = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.isISDemandOnlyInterstitialReady( _instanceId ); + 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_showOfferwall(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + gen_to_be_invoked.showOfferwall( ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _placementName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.showOfferwall( _placementName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnsupportedPlatformAgent.showOfferwall!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_getOfferwallCredits(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.getOfferwallCredits( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_isOfferwallAvailable(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.isOfferwallAvailable( ); + 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_loadBanner(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)) + { + IronSourceBannerSize _size = (IronSourceBannerSize)translator.GetObject(L, 2, typeof(IronSourceBannerSize)); + IronSourceBannerPosition _position;translator.Get(L, 3, out _position); + + gen_to_be_invoked.loadBanner( _size, _position ); + + + + return 0; + } + if(gen_param_count == 4&& translator.Assignable(L, 2)&& translator.Assignable(L, 3)&& (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING)) + { + IronSourceBannerSize _size = (IronSourceBannerSize)translator.GetObject(L, 2, typeof(IronSourceBannerSize)); + IronSourceBannerPosition _position;translator.Get(L, 3, out _position); + string _placementName = LuaAPI.lua_tostring(L, 4); + + gen_to_be_invoked.loadBanner( _size, _position, _placementName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to UnsupportedPlatformAgent.loadBanner!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_destroyBanner(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.destroyBanner( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_displayBanner(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.displayBanner( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_hideBanner(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.hideBanner( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_isBannerPlacementCapped(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + string _placementName = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.isBannerPlacementCapped( _placementName ); + 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_setSegment(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + IronSourceSegment _segment = (IronSourceSegment)translator.GetObject(L, 2, typeof(IronSourceSegment)); + + gen_to_be_invoked.setSegment( _segment ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setConsent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + bool _consent = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.setConsent( _consent ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_loadConsentViewWithType(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + string _consentViewType = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.loadConsentViewWithType( _consentViewType ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_showConsentViewWithType(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + string _consentViewType = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.showConsentViewWithType( _consentViewType ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setAdRevenueData(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + string _dataSource = LuaAPI.lua_tostring(L, 2); + System.Collections.Generic.Dictionary _impressionData = (System.Collections.Generic.Dictionary)translator.GetObject(L, 3, typeof(System.Collections.Generic.Dictionary)); + + gen_to_be_invoked.setAdRevenueData( _dataSource, _impressionData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_launchTestSuite(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UnsupportedPlatformAgent gen_to_be_invoked = (UnsupportedPlatformAgent)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.launchTestSuite( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/UsersRequestWrap.cs b/Assets/XLua/Gen/UsersRequestWrap.cs new file mode 100644 index 000000000..54b6d3eb6 --- /dev/null +++ b/Assets/XLua/Gen/UsersRequestWrap.cs @@ -0,0 +1,282 @@ +#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 UsersRequestWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(UsersRequest); + Utils.BeginObjectRegister(type, L, translator, 0, 6, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Users", _m_Users); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UsersTokenLogin", _m_UsersTokenLogin); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UsersPost", _m_UsersPost); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UsersGet", _m_UsersGet); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UsersPut", _m_UsersPut); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "UsersDel", _m_UsersDel); + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 1, 1, 0); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "Instance", _g_get_Instance); + + + + 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 UsersRequest(); + 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 UsersRequest constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Users(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UsersRequest gen_to_be_invoked = (UsersRequest)translator.FastGetCSObj(L, 1); + + + + { + string _body = LuaAPI.lua_tostring(L, 2); + System.Action _complete = translator.GetDelegate>(L, 3); + + gen_to_be_invoked.Users( _body, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UsersTokenLogin(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UsersRequest gen_to_be_invoked = (UsersRequest)translator.FastGetCSObj(L, 1); + + + + { + string _token = LuaAPI.lua_tostring(L, 2); + string _body = LuaAPI.lua_tostring(L, 3); + System.Action _complete = translator.GetDelegate>(L, 4); + + gen_to_be_invoked.UsersTokenLogin( _token, _body, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UsersPost(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UsersRequest gen_to_be_invoked = (UsersRequest)translator.FastGetCSObj(L, 1); + + + + { + string _key = LuaAPI.lua_tostring(L, 2); + string _body = LuaAPI.lua_tostring(L, 3); + System.Action _complete = translator.GetDelegate>(L, 4); + + gen_to_be_invoked.UsersPost( _key, _body, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UsersGet(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UsersRequest gen_to_be_invoked = (UsersRequest)translator.FastGetCSObj(L, 1); + + + + { + string _key = LuaAPI.lua_tostring(L, 2); + string _body = LuaAPI.lua_tostring(L, 3); + System.Action _complete = translator.GetDelegate>(L, 4); + + gen_to_be_invoked.UsersGet( _key, _body, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UsersPut(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UsersRequest gen_to_be_invoked = (UsersRequest)translator.FastGetCSObj(L, 1); + + + + { + string _key = LuaAPI.lua_tostring(L, 2); + string _body = LuaAPI.lua_tostring(L, 3); + System.Action _complete = translator.GetDelegate>(L, 4); + + gen_to_be_invoked.UsersPut( _key, _body, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_UsersDel(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + UsersRequest gen_to_be_invoked = (UsersRequest)translator.FastGetCSObj(L, 1); + + + + { + string _key = LuaAPI.lua_tostring(L, 2); + string _body = LuaAPI.lua_tostring(L, 3); + System.Action _complete = translator.GetDelegate>(L, 4); + + gen_to_be_invoked.UsersDel( _key, _body, _complete ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Instance(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + translator.Push(L, UsersRequest.Instance); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/WaterfallConfigurationWrap.cs b/Assets/XLua/Gen/WaterfallConfigurationWrap.cs new file mode 100644 index 000000000..d131fdee9 --- /dev/null +++ b/Assets/XLua/Gen/WaterfallConfigurationWrap.cs @@ -0,0 +1,151 @@ +#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 WaterfallConfigurationWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(WaterfallConfiguration); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 2, 0); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Ceiling", _g_get_Ceiling); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Floor", _g_get_Floor); + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 3, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Builder", _m_Builder_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Empty", _m_Empty_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "WaterfallConfiguration does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Builder_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = WaterfallConfiguration.Builder( ); + 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_Empty_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = WaterfallConfiguration.Empty( ); + 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_Ceiling(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + WaterfallConfiguration gen_to_be_invoked = (WaterfallConfiguration)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.Ceiling); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Floor(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + WaterfallConfiguration gen_to_be_invoked = (WaterfallConfiguration)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.Floor); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/WaterfallConfiguration_WaterfallConfigurationBuilderWrap.cs b/Assets/XLua/Gen/WaterfallConfiguration_WaterfallConfigurationBuilderWrap.cs new file mode 100644 index 000000000..333a2eab4 --- /dev/null +++ b/Assets/XLua/Gen/WaterfallConfiguration_WaterfallConfigurationBuilderWrap.cs @@ -0,0 +1,156 @@ +#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 WaterfallConfigurationWaterfallConfigurationBuilderWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(WaterfallConfiguration.WaterfallConfigurationBuilder); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetCeiling", _m_SetCeiling); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetFloor", _m_SetFloor); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Build", _m_Build); + + + + + + 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, "WaterfallConfiguration.WaterfallConfigurationBuilder does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SetCeiling(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + WaterfallConfiguration.WaterfallConfigurationBuilder gen_to_be_invoked = (WaterfallConfiguration.WaterfallConfigurationBuilder)translator.FastGetCSObj(L, 1); + + + + { + double _ceiling = LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.SetCeiling( _ceiling ); + 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_SetFloor(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + WaterfallConfiguration.WaterfallConfigurationBuilder gen_to_be_invoked = (WaterfallConfiguration.WaterfallConfigurationBuilder)translator.FastGetCSObj(L, 1); + + + + { + double _floor = LuaAPI.lua_tonumber(L, 2); + + var gen_ret = gen_to_be_invoked.SetFloor( _floor ); + 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_Build(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + WaterfallConfiguration.WaterfallConfigurationBuilder gen_to_be_invoked = (WaterfallConfiguration.WaterfallConfigurationBuilder)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.Build( ); + 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/WrapPusher.cs b/Assets/XLua/Gen/WrapPusher.cs new file mode 100644 index 000000000..3d38670dc --- /dev/null +++ b/Assets/XLua/Gen/WrapPusher.cs @@ -0,0 +1,8546 @@ +#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 System; + + +namespace XLua +{ + public partial class ObjectTranslator + { + + class IniterAdderUnityEngineVector2 + { + static IniterAdderUnityEngineVector2() + { + LuaEnv.AddIniter(Init); + } + + static void Init(LuaEnv luaenv, ObjectTranslator translator) + { + + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineVector2, translator.Get, translator.UpdateUnityEngineVector2); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineVector3, translator.Get, translator.UpdateUnityEngineVector3); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineVector4, translator.Get, translator.UpdateUnityEngineVector4); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineColor, translator.Get, translator.UpdateUnityEngineColor); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineQuaternion, translator.Get, translator.UpdateUnityEngineQuaternion); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineRay, translator.Get, translator.UpdateUnityEngineRay); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineBounds, translator.Get, translator.UpdateUnityEngineBounds); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineRay2D, translator.Get, translator.UpdateUnityEngineRay2D); + translator.RegisterPushAndGetAndUpdate(translator.PushAdFormat, translator.Get, translator.UpdateAdFormat); + translator.RegisterPushAndGetAndUpdate(translator.PushIronSourceBannerPosition, translator.Get, translator.UpdateIronSourceBannerPosition); + translator.RegisterPushAndGetAndUpdate(translator.PushUIImageSheetAnimationAnimationType, translator.Get, translator.UpdateUIImageSheetAnimationAnimationType); + translator.RegisterPushAndGetAndUpdate(translator.PushUIImageSheetAnimationTimeType, translator.Get, translator.UpdateUIImageSheetAnimationTimeType); + translator.RegisterPushAndGetAndUpdate(translator.PushUIImageSheetAnimationStartFrameType, translator.Get, translator.UpdateUIImageSheetAnimationStartFrameType); + translator.RegisterPushAndGetAndUpdate(translator.PushSystemReflectionBindingFlags, translator.Get, translator.UpdateSystemReflectionBindingFlags); + translator.RegisterPushAndGetAndUpdate(translator.PushSystemDayOfWeek, translator.Get, translator.UpdateSystemDayOfWeek); + translator.RegisterPushAndGetAndUpdate(translator.PushSystemNetNetworkInformationIPStatus, translator.Get, translator.UpdateSystemNetNetworkInformationIPStatus); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineCameraGateFitMode, translator.Get, translator.UpdateUnityEngineCameraGateFitMode); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineCameraStereoscopicEye, translator.Get, translator.UpdateUnityEngineCameraStereoscopicEye); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineCameraMonoOrStereoscopicEye, translator.Get, translator.UpdateUnityEngineCameraMonoOrStereoscopicEye); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineCameraFieldOfViewAxis, translator.Get, translator.UpdateUnityEngineCameraFieldOfViewAxis); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineCameraRenderRequestMode, translator.Get, translator.UpdateUnityEngineCameraRenderRequestMode); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineCameraRenderRequestOutputSpace, translator.Get, translator.UpdateUnityEngineCameraRenderRequestOutputSpace); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineCameraSceneViewFilterMode, translator.Get, translator.UpdateUnityEngineCameraSceneViewFilterMode); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineRenderingLightShadowResolution, translator.Get, translator.UpdateUnityEngineRenderingLightShadowResolution); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineRenderTextureFormat, translator.Get, translator.UpdateUnityEngineRenderTextureFormat); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineRenderTextureReadWrite, translator.Get, translator.UpdateUnityEngineRenderTextureReadWrite); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineRigidbodyConstraints, translator.Get, translator.UpdateUnityEngineRigidbodyConstraints); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineTransparencySortMode, translator.Get, translator.UpdateUnityEngineTransparencySortMode); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineRectTransformAxis, translator.Get, translator.UpdateUnityEngineRectTransformAxis); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineRectTransformEdge, translator.Get, translator.UpdateUnityEngineRectTransformEdge); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineAnimatorCullingMode, translator.Get, translator.UpdateUnityEngineAnimatorCullingMode); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineSystemLanguage, translator.Get, translator.UpdateUnityEngineSystemLanguage); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineRenderingShadowCastingMode, translator.Get, translator.UpdateUnityEngineRenderingShadowCastingMode); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineTexture2DEXRFlags, translator.Get, translator.UpdateUnityEngineTexture2DEXRFlags); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineKeyCode, translator.Get, translator.UpdateUnityEngineKeyCode); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineNetworkReachability, translator.Get, translator.UpdateUnityEngineNetworkReachability); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineRuntimePlatform, translator.Get, translator.UpdateUnityEngineRuntimePlatform); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineRenderingCompareFunction, translator.Get, translator.UpdateUnityEngineRenderingCompareFunction); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineTextAnchor, translator.Get, translator.UpdateUnityEngineTextAnchor); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineBatteryStatus, translator.Get, translator.UpdateUnityEngineBatteryStatus); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineUIGraphicRaycasterBlockingObjects, translator.Get, translator.UpdateUnityEngineUIGraphicRaycasterBlockingObjects); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineUIImageType, translator.Get, translator.UpdateUnityEngineUIImageType); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineUIImageFillMethod, translator.Get, translator.UpdateUnityEngineUIImageFillMethod); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineUIImageOriginHorizontal, translator.Get, translator.UpdateUnityEngineUIImageOriginHorizontal); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineUIImageOriginVertical, translator.Get, translator.UpdateUnityEngineUIImageOriginVertical); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineUIImageOrigin90, translator.Get, translator.UpdateUnityEngineUIImageOrigin90); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineUIImageOrigin180, translator.Get, translator.UpdateUnityEngineUIImageOrigin180); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineUIImageOrigin360, translator.Get, translator.UpdateUnityEngineUIImageOrigin360); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineUIInputFieldContentType, translator.Get, translator.UpdateUnityEngineUIInputFieldContentType); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineUIInputFieldInputType, translator.Get, translator.UpdateUnityEngineUIInputFieldInputType); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineUIInputFieldCharacterValidation, translator.Get, translator.UpdateUnityEngineUIInputFieldCharacterValidation); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineUIInputFieldLineType, translator.Get, translator.UpdateUnityEngineUIInputFieldLineType); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineUIScrollRectMovementType, translator.Get, translator.UpdateUnityEngineUIScrollRectMovementType); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineUIScrollRectScrollbarVisibility, translator.Get, translator.UpdateUnityEngineUIScrollRectScrollbarVisibility); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineUISliderDirection, translator.Get, translator.UpdateUnityEngineUISliderDirection); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineUIToggleToggleTransition, translator.Get, translator.UpdateUnityEngineUIToggleToggleTransition); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineUIGridLayoutGroupCorner, translator.Get, translator.UpdateUnityEngineUIGridLayoutGroupCorner); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineUIGridLayoutGroupAxis, translator.Get, translator.UpdateUnityEngineUIGridLayoutGroupAxis); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEngineUIGridLayoutGroupConstraint, translator.Get, translator.UpdateUnityEngineUIGridLayoutGroupConstraint); + translator.RegisterPushAndGetAndUpdate(translator.PushSpineUnityBoneFollowerAxisOrientation, translator.Get, translator.UpdateSpineUnityBoneFollowerAxisOrientation); + translator.RegisterPushAndGetAndUpdate(translator.PushSpineUnitySkeletonGraphicLayoutMode, translator.Get, translator.UpdateSpineUnitySkeletonGraphicLayoutMode); + translator.RegisterPushAndGetAndUpdate(translator.PushTMProTextAlignmentOptions, translator.Get, translator.UpdateTMProTextAlignmentOptions); + translator.RegisterPushAndGetAndUpdate(translator.PushTMProTMP_InputFieldContentType, translator.Get, translator.UpdateTMProTMP_InputFieldContentType); + translator.RegisterPushAndGetAndUpdate(translator.PushTMProTMP_InputFieldInputType, translator.Get, translator.UpdateTMProTMP_InputFieldInputType); + translator.RegisterPushAndGetAndUpdate(translator.PushTMProTMP_InputFieldCharacterValidation, translator.Get, translator.UpdateTMProTMP_InputFieldCharacterValidation); + translator.RegisterPushAndGetAndUpdate(translator.PushTMProTMP_InputFieldLineType, translator.Get, translator.UpdateTMProTMP_InputFieldLineType); + translator.RegisterPushAndGetAndUpdate(translator.PushThinkingAnalyticsThinkingAnalyticsAPITATimeZone, translator.Get, translator.UpdateThinkingAnalyticsThinkingAnalyticsAPITATimeZone); + translator.RegisterPushAndGetAndUpdate(translator.PushThinkingAnalyticsThinkingAnalyticsAPITAMode, translator.Get, translator.UpdateThinkingAnalyticsThinkingAnalyticsAPITAMode); + translator.RegisterPushAndGetAndUpdate(translator.PushThinkingAnalyticsThinkingAnalyticsAPINetworkType, translator.Get, translator.UpdateThinkingAnalyticsThinkingAnalyticsAPINetworkType); + translator.RegisterPushAndGetAndUpdate(translator.PushDGTweeningAutoPlay, translator.Get, translator.UpdateDGTweeningAutoPlay); + translator.RegisterPushAndGetAndUpdate(translator.PushDGTweeningAxisConstraint, translator.Get, translator.UpdateDGTweeningAxisConstraint); + translator.RegisterPushAndGetAndUpdate(translator.PushDGTweeningEase, translator.Get, translator.UpdateDGTweeningEase); + translator.RegisterPushAndGetAndUpdate(translator.PushDGTweeningLogBehaviour, translator.Get, translator.UpdateDGTweeningLogBehaviour); + translator.RegisterPushAndGetAndUpdate(translator.PushDGTweeningLoopType, translator.Get, translator.UpdateDGTweeningLoopType); + translator.RegisterPushAndGetAndUpdate(translator.PushDGTweeningPathMode, translator.Get, translator.UpdateDGTweeningPathMode); + translator.RegisterPushAndGetAndUpdate(translator.PushDGTweeningPathType, translator.Get, translator.UpdateDGTweeningPathType); + translator.RegisterPushAndGetAndUpdate(translator.PushDGTweeningRotateMode, translator.Get, translator.UpdateDGTweeningRotateMode); + translator.RegisterPushAndGetAndUpdate(translator.PushDGTweeningScrambleMode, translator.Get, translator.UpdateDGTweeningScrambleMode); + translator.RegisterPushAndGetAndUpdate(translator.PushDGTweeningTweenType, translator.Get, translator.UpdateDGTweeningTweenType); + translator.RegisterPushAndGetAndUpdate(translator.PushDGTweeningUpdateType, translator.Get, translator.UpdateDGTweeningUpdateType); + translator.RegisterPushAndGetAndUpdate(translator.PushHttpRequestState, translator.Get, translator.UpdateHttpRequestState); + translator.RegisterPushAndGetAndUpdate(translator.PushUnityEnginePurchasingProductType, translator.Get, translator.UpdateUnityEnginePurchasingProductType); + translator.RegisterPushAndGetAndUpdate(translator.PushBFBFSliderFillDirection, translator.Get, translator.UpdateBFBFSliderFillDirection); + translator.RegisterPushAndGetAndUpdate(translator.PushBFScrollRectBaseOldMovementType, translator.Get, translator.UpdateBFScrollRectBaseOldMovementType); + translator.RegisterPushAndGetAndUpdate(translator.PushBFScrollRectBaseOldScrollbarVisibility, translator.Get, translator.UpdateBFScrollRectBaseOldScrollbarVisibility); + translator.RegisterPushAndGetAndUpdate(translator.PushBFNetServiceType, translator.Get, translator.UpdateBFNetServiceType); + translator.RegisterPushAndGetAndUpdate(translator.PushBFNetIncomingMessageType, translator.Get, translator.UpdateBFNetIncomingMessageType); + translator.RegisterPushAndGetAndUpdate(translator.PushBFTouchEventType, translator.Get, translator.UpdateBFTouchEventType); + translator.RegisterPushAndGetAndUpdate(translator.PushBFSelectEventType, translator.Get, translator.UpdateBFSelectEventType); + + } + } + + static IniterAdderUnityEngineVector2 s_IniterAdderUnityEngineVector2_dumb_obj = new IniterAdderUnityEngineVector2(); + static IniterAdderUnityEngineVector2 IniterAdderUnityEngineVector2_dumb_obj {get{return s_IniterAdderUnityEngineVector2_dumb_obj;}} + + + int UnityEngineVector2_TypeID = -1; + public void PushUnityEngineVector2(RealStatePtr L, UnityEngine.Vector2 val) + { + if (UnityEngineVector2_TypeID == -1) + { + bool is_first; + UnityEngineVector2_TypeID = getTypeId(L, typeof(UnityEngine.Vector2), out is_first); + + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 8, UnityEngineVector2_TypeID); + if (!CopyByValue.Pack(buff, 0, val)) + { + throw new Exception("pack fail fail for UnityEngine.Vector2 ,value="+val); + } + + } + + public void Get(RealStatePtr L, int index, out UnityEngine.Vector2 val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineVector2_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Vector2"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index);if (!CopyByValue.UnPack(buff, 0, out val)) + { + throw new Exception("unpack fail for UnityEngine.Vector2"); + } + } + else if (type ==LuaTypes.LUA_TTABLE) + { + CopyByValue.UnPack(this, L, index, out val); + } + else + { + val = (UnityEngine.Vector2)objectCasters.GetCaster(typeof(UnityEngine.Vector2))(L, index, null); + } + } + + public void UpdateUnityEngineVector2(RealStatePtr L, int index, UnityEngine.Vector2 val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineVector2_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Vector2"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, val)) + { + throw new Exception("pack fail for UnityEngine.Vector2 ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineVector3_TypeID = -1; + public void PushUnityEngineVector3(RealStatePtr L, UnityEngine.Vector3 val) + { + if (UnityEngineVector3_TypeID == -1) + { + bool is_first; + UnityEngineVector3_TypeID = getTypeId(L, typeof(UnityEngine.Vector3), out is_first); + + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 12, UnityEngineVector3_TypeID); + if (!CopyByValue.Pack(buff, 0, val)) + { + throw new Exception("pack fail fail for UnityEngine.Vector3 ,value="+val); + } + + } + + public void Get(RealStatePtr L, int index, out UnityEngine.Vector3 val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineVector3_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Vector3"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index);if (!CopyByValue.UnPack(buff, 0, out val)) + { + throw new Exception("unpack fail for UnityEngine.Vector3"); + } + } + else if (type ==LuaTypes.LUA_TTABLE) + { + CopyByValue.UnPack(this, L, index, out val); + } + else + { + val = (UnityEngine.Vector3)objectCasters.GetCaster(typeof(UnityEngine.Vector3))(L, index, null); + } + } + + public void UpdateUnityEngineVector3(RealStatePtr L, int index, UnityEngine.Vector3 val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineVector3_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Vector3"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, val)) + { + throw new Exception("pack fail for UnityEngine.Vector3 ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineVector4_TypeID = -1; + public void PushUnityEngineVector4(RealStatePtr L, UnityEngine.Vector4 val) + { + if (UnityEngineVector4_TypeID == -1) + { + bool is_first; + UnityEngineVector4_TypeID = getTypeId(L, typeof(UnityEngine.Vector4), out is_first); + + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 16, UnityEngineVector4_TypeID); + if (!CopyByValue.Pack(buff, 0, val)) + { + throw new Exception("pack fail fail for UnityEngine.Vector4 ,value="+val); + } + + } + + public void Get(RealStatePtr L, int index, out UnityEngine.Vector4 val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineVector4_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Vector4"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index);if (!CopyByValue.UnPack(buff, 0, out val)) + { + throw new Exception("unpack fail for UnityEngine.Vector4"); + } + } + else if (type ==LuaTypes.LUA_TTABLE) + { + CopyByValue.UnPack(this, L, index, out val); + } + else + { + val = (UnityEngine.Vector4)objectCasters.GetCaster(typeof(UnityEngine.Vector4))(L, index, null); + } + } + + public void UpdateUnityEngineVector4(RealStatePtr L, int index, UnityEngine.Vector4 val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineVector4_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Vector4"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, val)) + { + throw new Exception("pack fail for UnityEngine.Vector4 ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineColor_TypeID = -1; + public void PushUnityEngineColor(RealStatePtr L, UnityEngine.Color val) + { + if (UnityEngineColor_TypeID == -1) + { + bool is_first; + UnityEngineColor_TypeID = getTypeId(L, typeof(UnityEngine.Color), out is_first); + + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 16, UnityEngineColor_TypeID); + if (!CopyByValue.Pack(buff, 0, val)) + { + throw new Exception("pack fail fail for UnityEngine.Color ,value="+val); + } + + } + + public void Get(RealStatePtr L, int index, out UnityEngine.Color val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineColor_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Color"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index);if (!CopyByValue.UnPack(buff, 0, out val)) + { + throw new Exception("unpack fail for UnityEngine.Color"); + } + } + else if (type ==LuaTypes.LUA_TTABLE) + { + CopyByValue.UnPack(this, L, index, out val); + } + else + { + val = (UnityEngine.Color)objectCasters.GetCaster(typeof(UnityEngine.Color))(L, index, null); + } + } + + public void UpdateUnityEngineColor(RealStatePtr L, int index, UnityEngine.Color val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineColor_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Color"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, val)) + { + throw new Exception("pack fail for UnityEngine.Color ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineQuaternion_TypeID = -1; + public void PushUnityEngineQuaternion(RealStatePtr L, UnityEngine.Quaternion val) + { + if (UnityEngineQuaternion_TypeID == -1) + { + bool is_first; + UnityEngineQuaternion_TypeID = getTypeId(L, typeof(UnityEngine.Quaternion), out is_first); + + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 16, UnityEngineQuaternion_TypeID); + if (!CopyByValue.Pack(buff, 0, val)) + { + throw new Exception("pack fail fail for UnityEngine.Quaternion ,value="+val); + } + + } + + public void Get(RealStatePtr L, int index, out UnityEngine.Quaternion val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineQuaternion_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Quaternion"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index);if (!CopyByValue.UnPack(buff, 0, out val)) + { + throw new Exception("unpack fail for UnityEngine.Quaternion"); + } + } + else if (type ==LuaTypes.LUA_TTABLE) + { + CopyByValue.UnPack(this, L, index, out val); + } + else + { + val = (UnityEngine.Quaternion)objectCasters.GetCaster(typeof(UnityEngine.Quaternion))(L, index, null); + } + } + + public void UpdateUnityEngineQuaternion(RealStatePtr L, int index, UnityEngine.Quaternion val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineQuaternion_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Quaternion"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, val)) + { + throw new Exception("pack fail for UnityEngine.Quaternion ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineRay_TypeID = -1; + public void PushUnityEngineRay(RealStatePtr L, UnityEngine.Ray val) + { + if (UnityEngineRay_TypeID == -1) + { + bool is_first; + UnityEngineRay_TypeID = getTypeId(L, typeof(UnityEngine.Ray), out is_first); + + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 24, UnityEngineRay_TypeID); + if (!CopyByValue.Pack(buff, 0, val)) + { + throw new Exception("pack fail fail for UnityEngine.Ray ,value="+val); + } + + } + + public void Get(RealStatePtr L, int index, out UnityEngine.Ray val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineRay_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Ray"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index);if (!CopyByValue.UnPack(buff, 0, out val)) + { + throw new Exception("unpack fail for UnityEngine.Ray"); + } + } + else if (type ==LuaTypes.LUA_TTABLE) + { + CopyByValue.UnPack(this, L, index, out val); + } + else + { + val = (UnityEngine.Ray)objectCasters.GetCaster(typeof(UnityEngine.Ray))(L, index, null); + } + } + + public void UpdateUnityEngineRay(RealStatePtr L, int index, UnityEngine.Ray val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineRay_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Ray"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, val)) + { + throw new Exception("pack fail for UnityEngine.Ray ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineBounds_TypeID = -1; + public void PushUnityEngineBounds(RealStatePtr L, UnityEngine.Bounds val) + { + if (UnityEngineBounds_TypeID == -1) + { + bool is_first; + UnityEngineBounds_TypeID = getTypeId(L, typeof(UnityEngine.Bounds), out is_first); + + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 24, UnityEngineBounds_TypeID); + if (!CopyByValue.Pack(buff, 0, val)) + { + throw new Exception("pack fail fail for UnityEngine.Bounds ,value="+val); + } + + } + + public void Get(RealStatePtr L, int index, out UnityEngine.Bounds val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineBounds_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Bounds"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index);if (!CopyByValue.UnPack(buff, 0, out val)) + { + throw new Exception("unpack fail for UnityEngine.Bounds"); + } + } + else if (type ==LuaTypes.LUA_TTABLE) + { + CopyByValue.UnPack(this, L, index, out val); + } + else + { + val = (UnityEngine.Bounds)objectCasters.GetCaster(typeof(UnityEngine.Bounds))(L, index, null); + } + } + + public void UpdateUnityEngineBounds(RealStatePtr L, int index, UnityEngine.Bounds val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineBounds_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Bounds"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, val)) + { + throw new Exception("pack fail for UnityEngine.Bounds ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineRay2D_TypeID = -1; + public void PushUnityEngineRay2D(RealStatePtr L, UnityEngine.Ray2D val) + { + if (UnityEngineRay2D_TypeID == -1) + { + bool is_first; + UnityEngineRay2D_TypeID = getTypeId(L, typeof(UnityEngine.Ray2D), out is_first); + + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 16, UnityEngineRay2D_TypeID); + if (!CopyByValue.Pack(buff, 0, val)) + { + throw new Exception("pack fail fail for UnityEngine.Ray2D ,value="+val); + } + + } + + public void Get(RealStatePtr L, int index, out UnityEngine.Ray2D val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineRay2D_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Ray2D"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index);if (!CopyByValue.UnPack(buff, 0, out val)) + { + throw new Exception("unpack fail for UnityEngine.Ray2D"); + } + } + else if (type ==LuaTypes.LUA_TTABLE) + { + CopyByValue.UnPack(this, L, index, out val); + } + else + { + val = (UnityEngine.Ray2D)objectCasters.GetCaster(typeof(UnityEngine.Ray2D))(L, index, null); + } + } + + public void UpdateUnityEngineRay2D(RealStatePtr L, int index, UnityEngine.Ray2D val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineRay2D_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Ray2D"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, val)) + { + throw new Exception("pack fail for UnityEngine.Ray2D ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int AdFormat_TypeID = -1; + int AdFormat_EnumRef = -1; + + public void PushAdFormat(RealStatePtr L, AdFormat val) + { + if (AdFormat_TypeID == -1) + { + bool is_first; + AdFormat_TypeID = getTypeId(L, typeof(AdFormat), out is_first); + + if (AdFormat_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(AdFormat)); + AdFormat_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, AdFormat_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, AdFormat_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for AdFormat ,value="+val); + } + + LuaAPI.lua_getref(L, AdFormat_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 AdFormat val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != AdFormat_TypeID) + { + throw new Exception("invalid userdata for AdFormat"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for AdFormat"); + } + val = (AdFormat)e; + + } + else + { + val = (AdFormat)objectCasters.GetCaster(typeof(AdFormat))(L, index, null); + } + } + + public void UpdateAdFormat(RealStatePtr L, int index, AdFormat val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != AdFormat_TypeID) + { + throw new Exception("invalid userdata for AdFormat"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for AdFormat ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int IronSourceBannerPosition_TypeID = -1; + int IronSourceBannerPosition_EnumRef = -1; + + public void PushIronSourceBannerPosition(RealStatePtr L, IronSourceBannerPosition val) + { + if (IronSourceBannerPosition_TypeID == -1) + { + bool is_first; + IronSourceBannerPosition_TypeID = getTypeId(L, typeof(IronSourceBannerPosition), out is_first); + + if (IronSourceBannerPosition_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(IronSourceBannerPosition)); + IronSourceBannerPosition_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, IronSourceBannerPosition_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, IronSourceBannerPosition_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for IronSourceBannerPosition ,value="+val); + } + + LuaAPI.lua_getref(L, IronSourceBannerPosition_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 IronSourceBannerPosition val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != IronSourceBannerPosition_TypeID) + { + throw new Exception("invalid userdata for IronSourceBannerPosition"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for IronSourceBannerPosition"); + } + val = (IronSourceBannerPosition)e; + + } + else + { + val = (IronSourceBannerPosition)objectCasters.GetCaster(typeof(IronSourceBannerPosition))(L, index, null); + } + } + + public void UpdateIronSourceBannerPosition(RealStatePtr L, int index, IronSourceBannerPosition val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != IronSourceBannerPosition_TypeID) + { + throw new Exception("invalid userdata for IronSourceBannerPosition"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for IronSourceBannerPosition ,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; + + public void PushUIImageSheetAnimationAnimationType(RealStatePtr L, UIImageSheetAnimation.AnimationType val) + { + if (UIImageSheetAnimationAnimationType_TypeID == -1) + { + bool is_first; + UIImageSheetAnimationAnimationType_TypeID = getTypeId(L, typeof(UIImageSheetAnimation.AnimationType), out is_first); + + if (UIImageSheetAnimationAnimationType_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UIImageSheetAnimation.AnimationType)); + UIImageSheetAnimationAnimationType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UIImageSheetAnimationAnimationType_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UIImageSheetAnimationAnimationType_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UIImageSheetAnimation.AnimationType ,value="+val); + } + + LuaAPI.lua_getref(L, UIImageSheetAnimationAnimationType_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 UIImageSheetAnimation.AnimationType val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UIImageSheetAnimationAnimationType_TypeID) + { + throw new Exception("invalid userdata for UIImageSheetAnimation.AnimationType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UIImageSheetAnimation.AnimationType"); + } + val = (UIImageSheetAnimation.AnimationType)e; + + } + else + { + val = (UIImageSheetAnimation.AnimationType)objectCasters.GetCaster(typeof(UIImageSheetAnimation.AnimationType))(L, index, null); + } + } + + public void UpdateUIImageSheetAnimationAnimationType(RealStatePtr L, int index, UIImageSheetAnimation.AnimationType val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UIImageSheetAnimationAnimationType_TypeID) + { + throw new Exception("invalid userdata for UIImageSheetAnimation.AnimationType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UIImageSheetAnimation.AnimationType ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UIImageSheetAnimationTimeType_TypeID = -1; + int UIImageSheetAnimationTimeType_EnumRef = -1; + + public void PushUIImageSheetAnimationTimeType(RealStatePtr L, UIImageSheetAnimation.TimeType val) + { + if (UIImageSheetAnimationTimeType_TypeID == -1) + { + bool is_first; + UIImageSheetAnimationTimeType_TypeID = getTypeId(L, typeof(UIImageSheetAnimation.TimeType), out is_first); + + if (UIImageSheetAnimationTimeType_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UIImageSheetAnimation.TimeType)); + UIImageSheetAnimationTimeType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UIImageSheetAnimationTimeType_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UIImageSheetAnimationTimeType_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UIImageSheetAnimation.TimeType ,value="+val); + } + + LuaAPI.lua_getref(L, UIImageSheetAnimationTimeType_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 UIImageSheetAnimation.TimeType val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UIImageSheetAnimationTimeType_TypeID) + { + throw new Exception("invalid userdata for UIImageSheetAnimation.TimeType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UIImageSheetAnimation.TimeType"); + } + val = (UIImageSheetAnimation.TimeType)e; + + } + else + { + val = (UIImageSheetAnimation.TimeType)objectCasters.GetCaster(typeof(UIImageSheetAnimation.TimeType))(L, index, null); + } + } + + public void UpdateUIImageSheetAnimationTimeType(RealStatePtr L, int index, UIImageSheetAnimation.TimeType val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UIImageSheetAnimationTimeType_TypeID) + { + throw new Exception("invalid userdata for UIImageSheetAnimation.TimeType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UIImageSheetAnimation.TimeType ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UIImageSheetAnimationStartFrameType_TypeID = -1; + int UIImageSheetAnimationStartFrameType_EnumRef = -1; + + public void PushUIImageSheetAnimationStartFrameType(RealStatePtr L, UIImageSheetAnimation.StartFrameType val) + { + if (UIImageSheetAnimationStartFrameType_TypeID == -1) + { + bool is_first; + UIImageSheetAnimationStartFrameType_TypeID = getTypeId(L, typeof(UIImageSheetAnimation.StartFrameType), out is_first); + + if (UIImageSheetAnimationStartFrameType_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UIImageSheetAnimation.StartFrameType)); + UIImageSheetAnimationStartFrameType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UIImageSheetAnimationStartFrameType_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UIImageSheetAnimationStartFrameType_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UIImageSheetAnimation.StartFrameType ,value="+val); + } + + LuaAPI.lua_getref(L, UIImageSheetAnimationStartFrameType_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 UIImageSheetAnimation.StartFrameType val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UIImageSheetAnimationStartFrameType_TypeID) + { + throw new Exception("invalid userdata for UIImageSheetAnimation.StartFrameType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UIImageSheetAnimation.StartFrameType"); + } + val = (UIImageSheetAnimation.StartFrameType)e; + + } + else + { + val = (UIImageSheetAnimation.StartFrameType)objectCasters.GetCaster(typeof(UIImageSheetAnimation.StartFrameType))(L, index, null); + } + } + + public void UpdateUIImageSheetAnimationStartFrameType(RealStatePtr L, int index, UIImageSheetAnimation.StartFrameType val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UIImageSheetAnimationStartFrameType_TypeID) + { + throw new Exception("invalid userdata for UIImageSheetAnimation.StartFrameType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UIImageSheetAnimation.StartFrameType ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int SystemReflectionBindingFlags_TypeID = -1; + int SystemReflectionBindingFlags_EnumRef = -1; + + public void PushSystemReflectionBindingFlags(RealStatePtr L, System.Reflection.BindingFlags val) + { + if (SystemReflectionBindingFlags_TypeID == -1) + { + bool is_first; + SystemReflectionBindingFlags_TypeID = getTypeId(L, typeof(System.Reflection.BindingFlags), out is_first); + + if (SystemReflectionBindingFlags_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(System.Reflection.BindingFlags)); + SystemReflectionBindingFlags_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, SystemReflectionBindingFlags_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, SystemReflectionBindingFlags_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for System.Reflection.BindingFlags ,value="+val); + } + + LuaAPI.lua_getref(L, SystemReflectionBindingFlags_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 System.Reflection.BindingFlags val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != SystemReflectionBindingFlags_TypeID) + { + throw new Exception("invalid userdata for System.Reflection.BindingFlags"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for System.Reflection.BindingFlags"); + } + val = (System.Reflection.BindingFlags)e; + + } + else + { + val = (System.Reflection.BindingFlags)objectCasters.GetCaster(typeof(System.Reflection.BindingFlags))(L, index, null); + } + } + + public void UpdateSystemReflectionBindingFlags(RealStatePtr L, int index, System.Reflection.BindingFlags val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != SystemReflectionBindingFlags_TypeID) + { + throw new Exception("invalid userdata for System.Reflection.BindingFlags"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for System.Reflection.BindingFlags ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int SystemDayOfWeek_TypeID = -1; + int SystemDayOfWeek_EnumRef = -1; + + public void PushSystemDayOfWeek(RealStatePtr L, System.DayOfWeek val) + { + if (SystemDayOfWeek_TypeID == -1) + { + bool is_first; + SystemDayOfWeek_TypeID = getTypeId(L, typeof(System.DayOfWeek), out is_first); + + if (SystemDayOfWeek_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(System.DayOfWeek)); + SystemDayOfWeek_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, SystemDayOfWeek_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, SystemDayOfWeek_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for System.DayOfWeek ,value="+val); + } + + LuaAPI.lua_getref(L, SystemDayOfWeek_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 System.DayOfWeek val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != SystemDayOfWeek_TypeID) + { + throw new Exception("invalid userdata for System.DayOfWeek"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for System.DayOfWeek"); + } + val = (System.DayOfWeek)e; + + } + else + { + val = (System.DayOfWeek)objectCasters.GetCaster(typeof(System.DayOfWeek))(L, index, null); + } + } + + public void UpdateSystemDayOfWeek(RealStatePtr L, int index, System.DayOfWeek val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != SystemDayOfWeek_TypeID) + { + throw new Exception("invalid userdata for System.DayOfWeek"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for System.DayOfWeek ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int SystemNetNetworkInformationIPStatus_TypeID = -1; + int SystemNetNetworkInformationIPStatus_EnumRef = -1; + + public void PushSystemNetNetworkInformationIPStatus(RealStatePtr L, System.Net.NetworkInformation.IPStatus val) + { + if (SystemNetNetworkInformationIPStatus_TypeID == -1) + { + bool is_first; + SystemNetNetworkInformationIPStatus_TypeID = getTypeId(L, typeof(System.Net.NetworkInformation.IPStatus), out is_first); + + if (SystemNetNetworkInformationIPStatus_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(System.Net.NetworkInformation.IPStatus)); + SystemNetNetworkInformationIPStatus_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, SystemNetNetworkInformationIPStatus_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, SystemNetNetworkInformationIPStatus_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for System.Net.NetworkInformation.IPStatus ,value="+val); + } + + LuaAPI.lua_getref(L, SystemNetNetworkInformationIPStatus_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 System.Net.NetworkInformation.IPStatus val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != SystemNetNetworkInformationIPStatus_TypeID) + { + throw new Exception("invalid userdata for System.Net.NetworkInformation.IPStatus"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for System.Net.NetworkInformation.IPStatus"); + } + val = (System.Net.NetworkInformation.IPStatus)e; + + } + else + { + val = (System.Net.NetworkInformation.IPStatus)objectCasters.GetCaster(typeof(System.Net.NetworkInformation.IPStatus))(L, index, null); + } + } + + public void UpdateSystemNetNetworkInformationIPStatus(RealStatePtr L, int index, System.Net.NetworkInformation.IPStatus val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != SystemNetNetworkInformationIPStatus_TypeID) + { + throw new Exception("invalid userdata for System.Net.NetworkInformation.IPStatus"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for System.Net.NetworkInformation.IPStatus ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineCameraGateFitMode_TypeID = -1; + int UnityEngineCameraGateFitMode_EnumRef = -1; + + public void PushUnityEngineCameraGateFitMode(RealStatePtr L, UnityEngine.Camera.GateFitMode val) + { + if (UnityEngineCameraGateFitMode_TypeID == -1) + { + bool is_first; + UnityEngineCameraGateFitMode_TypeID = getTypeId(L, typeof(UnityEngine.Camera.GateFitMode), out is_first); + + if (UnityEngineCameraGateFitMode_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.Camera.GateFitMode)); + UnityEngineCameraGateFitMode_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineCameraGateFitMode_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineCameraGateFitMode_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.Camera.GateFitMode ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineCameraGateFitMode_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 UnityEngine.Camera.GateFitMode val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineCameraGateFitMode_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Camera.GateFitMode"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.Camera.GateFitMode"); + } + val = (UnityEngine.Camera.GateFitMode)e; + + } + else + { + val = (UnityEngine.Camera.GateFitMode)objectCasters.GetCaster(typeof(UnityEngine.Camera.GateFitMode))(L, index, null); + } + } + + public void UpdateUnityEngineCameraGateFitMode(RealStatePtr L, int index, UnityEngine.Camera.GateFitMode val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineCameraGateFitMode_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Camera.GateFitMode"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.Camera.GateFitMode ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineCameraStereoscopicEye_TypeID = -1; + int UnityEngineCameraStereoscopicEye_EnumRef = -1; + + public void PushUnityEngineCameraStereoscopicEye(RealStatePtr L, UnityEngine.Camera.StereoscopicEye val) + { + if (UnityEngineCameraStereoscopicEye_TypeID == -1) + { + bool is_first; + UnityEngineCameraStereoscopicEye_TypeID = getTypeId(L, typeof(UnityEngine.Camera.StereoscopicEye), out is_first); + + if (UnityEngineCameraStereoscopicEye_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.Camera.StereoscopicEye)); + UnityEngineCameraStereoscopicEye_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineCameraStereoscopicEye_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineCameraStereoscopicEye_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.Camera.StereoscopicEye ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineCameraStereoscopicEye_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 UnityEngine.Camera.StereoscopicEye val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineCameraStereoscopicEye_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Camera.StereoscopicEye"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.Camera.StereoscopicEye"); + } + val = (UnityEngine.Camera.StereoscopicEye)e; + + } + else + { + val = (UnityEngine.Camera.StereoscopicEye)objectCasters.GetCaster(typeof(UnityEngine.Camera.StereoscopicEye))(L, index, null); + } + } + + public void UpdateUnityEngineCameraStereoscopicEye(RealStatePtr L, int index, UnityEngine.Camera.StereoscopicEye val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineCameraStereoscopicEye_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Camera.StereoscopicEye"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.Camera.StereoscopicEye ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineCameraMonoOrStereoscopicEye_TypeID = -1; + int UnityEngineCameraMonoOrStereoscopicEye_EnumRef = -1; + + public void PushUnityEngineCameraMonoOrStereoscopicEye(RealStatePtr L, UnityEngine.Camera.MonoOrStereoscopicEye val) + { + if (UnityEngineCameraMonoOrStereoscopicEye_TypeID == -1) + { + bool is_first; + UnityEngineCameraMonoOrStereoscopicEye_TypeID = getTypeId(L, typeof(UnityEngine.Camera.MonoOrStereoscopicEye), out is_first); + + if (UnityEngineCameraMonoOrStereoscopicEye_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.Camera.MonoOrStereoscopicEye)); + UnityEngineCameraMonoOrStereoscopicEye_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineCameraMonoOrStereoscopicEye_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineCameraMonoOrStereoscopicEye_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.Camera.MonoOrStereoscopicEye ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineCameraMonoOrStereoscopicEye_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 UnityEngine.Camera.MonoOrStereoscopicEye val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineCameraMonoOrStereoscopicEye_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Camera.MonoOrStereoscopicEye"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.Camera.MonoOrStereoscopicEye"); + } + val = (UnityEngine.Camera.MonoOrStereoscopicEye)e; + + } + else + { + val = (UnityEngine.Camera.MonoOrStereoscopicEye)objectCasters.GetCaster(typeof(UnityEngine.Camera.MonoOrStereoscopicEye))(L, index, null); + } + } + + public void UpdateUnityEngineCameraMonoOrStereoscopicEye(RealStatePtr L, int index, UnityEngine.Camera.MonoOrStereoscopicEye val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineCameraMonoOrStereoscopicEye_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Camera.MonoOrStereoscopicEye"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.Camera.MonoOrStereoscopicEye ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineCameraFieldOfViewAxis_TypeID = -1; + int UnityEngineCameraFieldOfViewAxis_EnumRef = -1; + + public void PushUnityEngineCameraFieldOfViewAxis(RealStatePtr L, UnityEngine.Camera.FieldOfViewAxis val) + { + if (UnityEngineCameraFieldOfViewAxis_TypeID == -1) + { + bool is_first; + UnityEngineCameraFieldOfViewAxis_TypeID = getTypeId(L, typeof(UnityEngine.Camera.FieldOfViewAxis), out is_first); + + if (UnityEngineCameraFieldOfViewAxis_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.Camera.FieldOfViewAxis)); + UnityEngineCameraFieldOfViewAxis_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineCameraFieldOfViewAxis_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineCameraFieldOfViewAxis_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.Camera.FieldOfViewAxis ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineCameraFieldOfViewAxis_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 UnityEngine.Camera.FieldOfViewAxis val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineCameraFieldOfViewAxis_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Camera.FieldOfViewAxis"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.Camera.FieldOfViewAxis"); + } + val = (UnityEngine.Camera.FieldOfViewAxis)e; + + } + else + { + val = (UnityEngine.Camera.FieldOfViewAxis)objectCasters.GetCaster(typeof(UnityEngine.Camera.FieldOfViewAxis))(L, index, null); + } + } + + public void UpdateUnityEngineCameraFieldOfViewAxis(RealStatePtr L, int index, UnityEngine.Camera.FieldOfViewAxis val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineCameraFieldOfViewAxis_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Camera.FieldOfViewAxis"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.Camera.FieldOfViewAxis ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineCameraRenderRequestMode_TypeID = -1; + int UnityEngineCameraRenderRequestMode_EnumRef = -1; + + public void PushUnityEngineCameraRenderRequestMode(RealStatePtr L, UnityEngine.Camera.RenderRequestMode val) + { + if (UnityEngineCameraRenderRequestMode_TypeID == -1) + { + bool is_first; + UnityEngineCameraRenderRequestMode_TypeID = getTypeId(L, typeof(UnityEngine.Camera.RenderRequestMode), out is_first); + + if (UnityEngineCameraRenderRequestMode_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.Camera.RenderRequestMode)); + UnityEngineCameraRenderRequestMode_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineCameraRenderRequestMode_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineCameraRenderRequestMode_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.Camera.RenderRequestMode ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineCameraRenderRequestMode_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 UnityEngine.Camera.RenderRequestMode val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineCameraRenderRequestMode_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Camera.RenderRequestMode"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.Camera.RenderRequestMode"); + } + val = (UnityEngine.Camera.RenderRequestMode)e; + + } + else + { + val = (UnityEngine.Camera.RenderRequestMode)objectCasters.GetCaster(typeof(UnityEngine.Camera.RenderRequestMode))(L, index, null); + } + } + + public void UpdateUnityEngineCameraRenderRequestMode(RealStatePtr L, int index, UnityEngine.Camera.RenderRequestMode val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineCameraRenderRequestMode_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Camera.RenderRequestMode"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.Camera.RenderRequestMode ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineCameraRenderRequestOutputSpace_TypeID = -1; + int UnityEngineCameraRenderRequestOutputSpace_EnumRef = -1; + + public void PushUnityEngineCameraRenderRequestOutputSpace(RealStatePtr L, UnityEngine.Camera.RenderRequestOutputSpace val) + { + if (UnityEngineCameraRenderRequestOutputSpace_TypeID == -1) + { + bool is_first; + UnityEngineCameraRenderRequestOutputSpace_TypeID = getTypeId(L, typeof(UnityEngine.Camera.RenderRequestOutputSpace), out is_first); + + if (UnityEngineCameraRenderRequestOutputSpace_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.Camera.RenderRequestOutputSpace)); + UnityEngineCameraRenderRequestOutputSpace_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineCameraRenderRequestOutputSpace_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineCameraRenderRequestOutputSpace_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.Camera.RenderRequestOutputSpace ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineCameraRenderRequestOutputSpace_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 UnityEngine.Camera.RenderRequestOutputSpace val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineCameraRenderRequestOutputSpace_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Camera.RenderRequestOutputSpace"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.Camera.RenderRequestOutputSpace"); + } + val = (UnityEngine.Camera.RenderRequestOutputSpace)e; + + } + else + { + val = (UnityEngine.Camera.RenderRequestOutputSpace)objectCasters.GetCaster(typeof(UnityEngine.Camera.RenderRequestOutputSpace))(L, index, null); + } + } + + public void UpdateUnityEngineCameraRenderRequestOutputSpace(RealStatePtr L, int index, UnityEngine.Camera.RenderRequestOutputSpace val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineCameraRenderRequestOutputSpace_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Camera.RenderRequestOutputSpace"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.Camera.RenderRequestOutputSpace ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineCameraSceneViewFilterMode_TypeID = -1; + int UnityEngineCameraSceneViewFilterMode_EnumRef = -1; + + public void PushUnityEngineCameraSceneViewFilterMode(RealStatePtr L, UnityEngine.Camera.SceneViewFilterMode val) + { + if (UnityEngineCameraSceneViewFilterMode_TypeID == -1) + { + bool is_first; + UnityEngineCameraSceneViewFilterMode_TypeID = getTypeId(L, typeof(UnityEngine.Camera.SceneViewFilterMode), out is_first); + + if (UnityEngineCameraSceneViewFilterMode_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.Camera.SceneViewFilterMode)); + UnityEngineCameraSceneViewFilterMode_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineCameraSceneViewFilterMode_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineCameraSceneViewFilterMode_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.Camera.SceneViewFilterMode ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineCameraSceneViewFilterMode_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 UnityEngine.Camera.SceneViewFilterMode val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineCameraSceneViewFilterMode_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Camera.SceneViewFilterMode"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.Camera.SceneViewFilterMode"); + } + val = (UnityEngine.Camera.SceneViewFilterMode)e; + + } + else + { + val = (UnityEngine.Camera.SceneViewFilterMode)objectCasters.GetCaster(typeof(UnityEngine.Camera.SceneViewFilterMode))(L, index, null); + } + } + + public void UpdateUnityEngineCameraSceneViewFilterMode(RealStatePtr L, int index, UnityEngine.Camera.SceneViewFilterMode val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineCameraSceneViewFilterMode_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Camera.SceneViewFilterMode"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.Camera.SceneViewFilterMode ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineRenderingLightShadowResolution_TypeID = -1; + int UnityEngineRenderingLightShadowResolution_EnumRef = -1; + + public void PushUnityEngineRenderingLightShadowResolution(RealStatePtr L, UnityEngine.Rendering.LightShadowResolution val) + { + if (UnityEngineRenderingLightShadowResolution_TypeID == -1) + { + bool is_first; + UnityEngineRenderingLightShadowResolution_TypeID = getTypeId(L, typeof(UnityEngine.Rendering.LightShadowResolution), out is_first); + + if (UnityEngineRenderingLightShadowResolution_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.Rendering.LightShadowResolution)); + UnityEngineRenderingLightShadowResolution_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineRenderingLightShadowResolution_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineRenderingLightShadowResolution_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.Rendering.LightShadowResolution ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineRenderingLightShadowResolution_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 UnityEngine.Rendering.LightShadowResolution val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineRenderingLightShadowResolution_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Rendering.LightShadowResolution"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.Rendering.LightShadowResolution"); + } + val = (UnityEngine.Rendering.LightShadowResolution)e; + + } + else + { + val = (UnityEngine.Rendering.LightShadowResolution)objectCasters.GetCaster(typeof(UnityEngine.Rendering.LightShadowResolution))(L, index, null); + } + } + + public void UpdateUnityEngineRenderingLightShadowResolution(RealStatePtr L, int index, UnityEngine.Rendering.LightShadowResolution val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineRenderingLightShadowResolution_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Rendering.LightShadowResolution"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.Rendering.LightShadowResolution ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineRenderTextureFormat_TypeID = -1; + int UnityEngineRenderTextureFormat_EnumRef = -1; + + public void PushUnityEngineRenderTextureFormat(RealStatePtr L, UnityEngine.RenderTextureFormat val) + { + if (UnityEngineRenderTextureFormat_TypeID == -1) + { + bool is_first; + UnityEngineRenderTextureFormat_TypeID = getTypeId(L, typeof(UnityEngine.RenderTextureFormat), out is_first); + + if (UnityEngineRenderTextureFormat_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.RenderTextureFormat)); + UnityEngineRenderTextureFormat_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineRenderTextureFormat_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineRenderTextureFormat_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.RenderTextureFormat ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineRenderTextureFormat_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 UnityEngine.RenderTextureFormat val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineRenderTextureFormat_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.RenderTextureFormat"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.RenderTextureFormat"); + } + val = (UnityEngine.RenderTextureFormat)e; + + } + else + { + val = (UnityEngine.RenderTextureFormat)objectCasters.GetCaster(typeof(UnityEngine.RenderTextureFormat))(L, index, null); + } + } + + public void UpdateUnityEngineRenderTextureFormat(RealStatePtr L, int index, UnityEngine.RenderTextureFormat val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineRenderTextureFormat_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.RenderTextureFormat"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.RenderTextureFormat ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineRenderTextureReadWrite_TypeID = -1; + int UnityEngineRenderTextureReadWrite_EnumRef = -1; + + public void PushUnityEngineRenderTextureReadWrite(RealStatePtr L, UnityEngine.RenderTextureReadWrite val) + { + if (UnityEngineRenderTextureReadWrite_TypeID == -1) + { + bool is_first; + UnityEngineRenderTextureReadWrite_TypeID = getTypeId(L, typeof(UnityEngine.RenderTextureReadWrite), out is_first); + + if (UnityEngineRenderTextureReadWrite_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.RenderTextureReadWrite)); + UnityEngineRenderTextureReadWrite_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineRenderTextureReadWrite_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineRenderTextureReadWrite_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.RenderTextureReadWrite ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineRenderTextureReadWrite_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 UnityEngine.RenderTextureReadWrite val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineRenderTextureReadWrite_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.RenderTextureReadWrite"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.RenderTextureReadWrite"); + } + val = (UnityEngine.RenderTextureReadWrite)e; + + } + else + { + val = (UnityEngine.RenderTextureReadWrite)objectCasters.GetCaster(typeof(UnityEngine.RenderTextureReadWrite))(L, index, null); + } + } + + public void UpdateUnityEngineRenderTextureReadWrite(RealStatePtr L, int index, UnityEngine.RenderTextureReadWrite val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineRenderTextureReadWrite_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.RenderTextureReadWrite"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.RenderTextureReadWrite ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineRigidbodyConstraints_TypeID = -1; + int UnityEngineRigidbodyConstraints_EnumRef = -1; + + public void PushUnityEngineRigidbodyConstraints(RealStatePtr L, UnityEngine.RigidbodyConstraints val) + { + if (UnityEngineRigidbodyConstraints_TypeID == -1) + { + bool is_first; + UnityEngineRigidbodyConstraints_TypeID = getTypeId(L, typeof(UnityEngine.RigidbodyConstraints), out is_first); + + if (UnityEngineRigidbodyConstraints_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.RigidbodyConstraints)); + UnityEngineRigidbodyConstraints_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineRigidbodyConstraints_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineRigidbodyConstraints_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.RigidbodyConstraints ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineRigidbodyConstraints_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 UnityEngine.RigidbodyConstraints val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineRigidbodyConstraints_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.RigidbodyConstraints"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.RigidbodyConstraints"); + } + val = (UnityEngine.RigidbodyConstraints)e; + + } + else + { + val = (UnityEngine.RigidbodyConstraints)objectCasters.GetCaster(typeof(UnityEngine.RigidbodyConstraints))(L, index, null); + } + } + + public void UpdateUnityEngineRigidbodyConstraints(RealStatePtr L, int index, UnityEngine.RigidbodyConstraints val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineRigidbodyConstraints_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.RigidbodyConstraints"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.RigidbodyConstraints ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineTransparencySortMode_TypeID = -1; + int UnityEngineTransparencySortMode_EnumRef = -1; + + public void PushUnityEngineTransparencySortMode(RealStatePtr L, UnityEngine.TransparencySortMode val) + { + if (UnityEngineTransparencySortMode_TypeID == -1) + { + bool is_first; + UnityEngineTransparencySortMode_TypeID = getTypeId(L, typeof(UnityEngine.TransparencySortMode), out is_first); + + if (UnityEngineTransparencySortMode_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.TransparencySortMode)); + UnityEngineTransparencySortMode_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineTransparencySortMode_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineTransparencySortMode_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.TransparencySortMode ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineTransparencySortMode_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 UnityEngine.TransparencySortMode val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineTransparencySortMode_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.TransparencySortMode"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.TransparencySortMode"); + } + val = (UnityEngine.TransparencySortMode)e; + + } + else + { + val = (UnityEngine.TransparencySortMode)objectCasters.GetCaster(typeof(UnityEngine.TransparencySortMode))(L, index, null); + } + } + + public void UpdateUnityEngineTransparencySortMode(RealStatePtr L, int index, UnityEngine.TransparencySortMode val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineTransparencySortMode_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.TransparencySortMode"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.TransparencySortMode ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineRectTransformAxis_TypeID = -1; + int UnityEngineRectTransformAxis_EnumRef = -1; + + public void PushUnityEngineRectTransformAxis(RealStatePtr L, UnityEngine.RectTransform.Axis val) + { + if (UnityEngineRectTransformAxis_TypeID == -1) + { + bool is_first; + UnityEngineRectTransformAxis_TypeID = getTypeId(L, typeof(UnityEngine.RectTransform.Axis), out is_first); + + if (UnityEngineRectTransformAxis_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.RectTransform.Axis)); + UnityEngineRectTransformAxis_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineRectTransformAxis_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineRectTransformAxis_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.RectTransform.Axis ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineRectTransformAxis_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 UnityEngine.RectTransform.Axis val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineRectTransformAxis_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.RectTransform.Axis"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.RectTransform.Axis"); + } + val = (UnityEngine.RectTransform.Axis)e; + + } + else + { + val = (UnityEngine.RectTransform.Axis)objectCasters.GetCaster(typeof(UnityEngine.RectTransform.Axis))(L, index, null); + } + } + + public void UpdateUnityEngineRectTransformAxis(RealStatePtr L, int index, UnityEngine.RectTransform.Axis val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineRectTransformAxis_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.RectTransform.Axis"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.RectTransform.Axis ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineRectTransformEdge_TypeID = -1; + int UnityEngineRectTransformEdge_EnumRef = -1; + + public void PushUnityEngineRectTransformEdge(RealStatePtr L, UnityEngine.RectTransform.Edge val) + { + if (UnityEngineRectTransformEdge_TypeID == -1) + { + bool is_first; + UnityEngineRectTransformEdge_TypeID = getTypeId(L, typeof(UnityEngine.RectTransform.Edge), out is_first); + + if (UnityEngineRectTransformEdge_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.RectTransform.Edge)); + UnityEngineRectTransformEdge_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineRectTransformEdge_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineRectTransformEdge_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.RectTransform.Edge ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineRectTransformEdge_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 UnityEngine.RectTransform.Edge val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineRectTransformEdge_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.RectTransform.Edge"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.RectTransform.Edge"); + } + val = (UnityEngine.RectTransform.Edge)e; + + } + else + { + val = (UnityEngine.RectTransform.Edge)objectCasters.GetCaster(typeof(UnityEngine.RectTransform.Edge))(L, index, null); + } + } + + public void UpdateUnityEngineRectTransformEdge(RealStatePtr L, int index, UnityEngine.RectTransform.Edge val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineRectTransformEdge_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.RectTransform.Edge"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.RectTransform.Edge ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineAnimatorCullingMode_TypeID = -1; + int UnityEngineAnimatorCullingMode_EnumRef = -1; + + public void PushUnityEngineAnimatorCullingMode(RealStatePtr L, UnityEngine.AnimatorCullingMode val) + { + if (UnityEngineAnimatorCullingMode_TypeID == -1) + { + bool is_first; + UnityEngineAnimatorCullingMode_TypeID = getTypeId(L, typeof(UnityEngine.AnimatorCullingMode), out is_first); + + if (UnityEngineAnimatorCullingMode_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.AnimatorCullingMode)); + UnityEngineAnimatorCullingMode_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineAnimatorCullingMode_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineAnimatorCullingMode_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.AnimatorCullingMode ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineAnimatorCullingMode_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 UnityEngine.AnimatorCullingMode val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineAnimatorCullingMode_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.AnimatorCullingMode"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.AnimatorCullingMode"); + } + val = (UnityEngine.AnimatorCullingMode)e; + + } + else + { + val = (UnityEngine.AnimatorCullingMode)objectCasters.GetCaster(typeof(UnityEngine.AnimatorCullingMode))(L, index, null); + } + } + + public void UpdateUnityEngineAnimatorCullingMode(RealStatePtr L, int index, UnityEngine.AnimatorCullingMode val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineAnimatorCullingMode_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.AnimatorCullingMode"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.AnimatorCullingMode ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineSystemLanguage_TypeID = -1; + int UnityEngineSystemLanguage_EnumRef = -1; + + public void PushUnityEngineSystemLanguage(RealStatePtr L, UnityEngine.SystemLanguage val) + { + if (UnityEngineSystemLanguage_TypeID == -1) + { + bool is_first; + UnityEngineSystemLanguage_TypeID = getTypeId(L, typeof(UnityEngine.SystemLanguage), out is_first); + + if (UnityEngineSystemLanguage_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.SystemLanguage)); + UnityEngineSystemLanguage_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineSystemLanguage_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineSystemLanguage_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.SystemLanguage ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineSystemLanguage_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 UnityEngine.SystemLanguage val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineSystemLanguage_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.SystemLanguage"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.SystemLanguage"); + } + val = (UnityEngine.SystemLanguage)e; + + } + else + { + val = (UnityEngine.SystemLanguage)objectCasters.GetCaster(typeof(UnityEngine.SystemLanguage))(L, index, null); + } + } + + public void UpdateUnityEngineSystemLanguage(RealStatePtr L, int index, UnityEngine.SystemLanguage val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineSystemLanguage_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.SystemLanguage"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.SystemLanguage ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineRenderingShadowCastingMode_TypeID = -1; + int UnityEngineRenderingShadowCastingMode_EnumRef = -1; + + public void PushUnityEngineRenderingShadowCastingMode(RealStatePtr L, UnityEngine.Rendering.ShadowCastingMode val) + { + if (UnityEngineRenderingShadowCastingMode_TypeID == -1) + { + bool is_first; + UnityEngineRenderingShadowCastingMode_TypeID = getTypeId(L, typeof(UnityEngine.Rendering.ShadowCastingMode), out is_first); + + if (UnityEngineRenderingShadowCastingMode_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.Rendering.ShadowCastingMode)); + UnityEngineRenderingShadowCastingMode_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineRenderingShadowCastingMode_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineRenderingShadowCastingMode_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.Rendering.ShadowCastingMode ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineRenderingShadowCastingMode_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 UnityEngine.Rendering.ShadowCastingMode val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineRenderingShadowCastingMode_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Rendering.ShadowCastingMode"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.Rendering.ShadowCastingMode"); + } + val = (UnityEngine.Rendering.ShadowCastingMode)e; + + } + else + { + val = (UnityEngine.Rendering.ShadowCastingMode)objectCasters.GetCaster(typeof(UnityEngine.Rendering.ShadowCastingMode))(L, index, null); + } + } + + public void UpdateUnityEngineRenderingShadowCastingMode(RealStatePtr L, int index, UnityEngine.Rendering.ShadowCastingMode val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineRenderingShadowCastingMode_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Rendering.ShadowCastingMode"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.Rendering.ShadowCastingMode ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineTexture2DEXRFlags_TypeID = -1; + int UnityEngineTexture2DEXRFlags_EnumRef = -1; + + public void PushUnityEngineTexture2DEXRFlags(RealStatePtr L, UnityEngine.Texture2D.EXRFlags val) + { + if (UnityEngineTexture2DEXRFlags_TypeID == -1) + { + bool is_first; + UnityEngineTexture2DEXRFlags_TypeID = getTypeId(L, typeof(UnityEngine.Texture2D.EXRFlags), out is_first); + + if (UnityEngineTexture2DEXRFlags_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.Texture2D.EXRFlags)); + UnityEngineTexture2DEXRFlags_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineTexture2DEXRFlags_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineTexture2DEXRFlags_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.Texture2D.EXRFlags ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineTexture2DEXRFlags_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 UnityEngine.Texture2D.EXRFlags val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineTexture2DEXRFlags_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Texture2D.EXRFlags"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.Texture2D.EXRFlags"); + } + val = (UnityEngine.Texture2D.EXRFlags)e; + + } + else + { + val = (UnityEngine.Texture2D.EXRFlags)objectCasters.GetCaster(typeof(UnityEngine.Texture2D.EXRFlags))(L, index, null); + } + } + + public void UpdateUnityEngineTexture2DEXRFlags(RealStatePtr L, int index, UnityEngine.Texture2D.EXRFlags val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineTexture2DEXRFlags_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Texture2D.EXRFlags"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.Texture2D.EXRFlags ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineKeyCode_TypeID = -1; + int UnityEngineKeyCode_EnumRef = -1; + + public void PushUnityEngineKeyCode(RealStatePtr L, UnityEngine.KeyCode val) + { + if (UnityEngineKeyCode_TypeID == -1) + { + bool is_first; + UnityEngineKeyCode_TypeID = getTypeId(L, typeof(UnityEngine.KeyCode), out is_first); + + if (UnityEngineKeyCode_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.KeyCode)); + UnityEngineKeyCode_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineKeyCode_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineKeyCode_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.KeyCode ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineKeyCode_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 UnityEngine.KeyCode val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineKeyCode_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.KeyCode"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.KeyCode"); + } + val = (UnityEngine.KeyCode)e; + + } + else + { + val = (UnityEngine.KeyCode)objectCasters.GetCaster(typeof(UnityEngine.KeyCode))(L, index, null); + } + } + + public void UpdateUnityEngineKeyCode(RealStatePtr L, int index, UnityEngine.KeyCode val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineKeyCode_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.KeyCode"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.KeyCode ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineNetworkReachability_TypeID = -1; + int UnityEngineNetworkReachability_EnumRef = -1; + + public void PushUnityEngineNetworkReachability(RealStatePtr L, UnityEngine.NetworkReachability val) + { + if (UnityEngineNetworkReachability_TypeID == -1) + { + bool is_first; + UnityEngineNetworkReachability_TypeID = getTypeId(L, typeof(UnityEngine.NetworkReachability), out is_first); + + if (UnityEngineNetworkReachability_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.NetworkReachability)); + UnityEngineNetworkReachability_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineNetworkReachability_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineNetworkReachability_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.NetworkReachability ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineNetworkReachability_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 UnityEngine.NetworkReachability val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineNetworkReachability_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.NetworkReachability"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.NetworkReachability"); + } + val = (UnityEngine.NetworkReachability)e; + + } + else + { + val = (UnityEngine.NetworkReachability)objectCasters.GetCaster(typeof(UnityEngine.NetworkReachability))(L, index, null); + } + } + + public void UpdateUnityEngineNetworkReachability(RealStatePtr L, int index, UnityEngine.NetworkReachability val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineNetworkReachability_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.NetworkReachability"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.NetworkReachability ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineRuntimePlatform_TypeID = -1; + int UnityEngineRuntimePlatform_EnumRef = -1; + + public void PushUnityEngineRuntimePlatform(RealStatePtr L, UnityEngine.RuntimePlatform val) + { + if (UnityEngineRuntimePlatform_TypeID == -1) + { + bool is_first; + UnityEngineRuntimePlatform_TypeID = getTypeId(L, typeof(UnityEngine.RuntimePlatform), out is_first); + + if (UnityEngineRuntimePlatform_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.RuntimePlatform)); + UnityEngineRuntimePlatform_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineRuntimePlatform_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineRuntimePlatform_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.RuntimePlatform ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineRuntimePlatform_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 UnityEngine.RuntimePlatform val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineRuntimePlatform_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.RuntimePlatform"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.RuntimePlatform"); + } + val = (UnityEngine.RuntimePlatform)e; + + } + else + { + val = (UnityEngine.RuntimePlatform)objectCasters.GetCaster(typeof(UnityEngine.RuntimePlatform))(L, index, null); + } + } + + public void UpdateUnityEngineRuntimePlatform(RealStatePtr L, int index, UnityEngine.RuntimePlatform val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineRuntimePlatform_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.RuntimePlatform"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.RuntimePlatform ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineRenderingCompareFunction_TypeID = -1; + int UnityEngineRenderingCompareFunction_EnumRef = -1; + + public void PushUnityEngineRenderingCompareFunction(RealStatePtr L, UnityEngine.Rendering.CompareFunction val) + { + if (UnityEngineRenderingCompareFunction_TypeID == -1) + { + bool is_first; + UnityEngineRenderingCompareFunction_TypeID = getTypeId(L, typeof(UnityEngine.Rendering.CompareFunction), out is_first); + + if (UnityEngineRenderingCompareFunction_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.Rendering.CompareFunction)); + UnityEngineRenderingCompareFunction_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineRenderingCompareFunction_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineRenderingCompareFunction_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.Rendering.CompareFunction ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineRenderingCompareFunction_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 UnityEngine.Rendering.CompareFunction val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineRenderingCompareFunction_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Rendering.CompareFunction"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.Rendering.CompareFunction"); + } + val = (UnityEngine.Rendering.CompareFunction)e; + + } + else + { + val = (UnityEngine.Rendering.CompareFunction)objectCasters.GetCaster(typeof(UnityEngine.Rendering.CompareFunction))(L, index, null); + } + } + + public void UpdateUnityEngineRenderingCompareFunction(RealStatePtr L, int index, UnityEngine.Rendering.CompareFunction val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineRenderingCompareFunction_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Rendering.CompareFunction"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.Rendering.CompareFunction ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineTextAnchor_TypeID = -1; + int UnityEngineTextAnchor_EnumRef = -1; + + public void PushUnityEngineTextAnchor(RealStatePtr L, UnityEngine.TextAnchor val) + { + if (UnityEngineTextAnchor_TypeID == -1) + { + bool is_first; + UnityEngineTextAnchor_TypeID = getTypeId(L, typeof(UnityEngine.TextAnchor), out is_first); + + if (UnityEngineTextAnchor_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.TextAnchor)); + UnityEngineTextAnchor_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineTextAnchor_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineTextAnchor_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.TextAnchor ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineTextAnchor_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 UnityEngine.TextAnchor val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineTextAnchor_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.TextAnchor"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.TextAnchor"); + } + val = (UnityEngine.TextAnchor)e; + + } + else + { + val = (UnityEngine.TextAnchor)objectCasters.GetCaster(typeof(UnityEngine.TextAnchor))(L, index, null); + } + } + + public void UpdateUnityEngineTextAnchor(RealStatePtr L, int index, UnityEngine.TextAnchor val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineTextAnchor_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.TextAnchor"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.TextAnchor ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineBatteryStatus_TypeID = -1; + int UnityEngineBatteryStatus_EnumRef = -1; + + public void PushUnityEngineBatteryStatus(RealStatePtr L, UnityEngine.BatteryStatus val) + { + if (UnityEngineBatteryStatus_TypeID == -1) + { + bool is_first; + UnityEngineBatteryStatus_TypeID = getTypeId(L, typeof(UnityEngine.BatteryStatus), out is_first); + + if (UnityEngineBatteryStatus_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.BatteryStatus)); + UnityEngineBatteryStatus_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineBatteryStatus_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineBatteryStatus_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.BatteryStatus ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineBatteryStatus_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 UnityEngine.BatteryStatus val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineBatteryStatus_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.BatteryStatus"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.BatteryStatus"); + } + val = (UnityEngine.BatteryStatus)e; + + } + else + { + val = (UnityEngine.BatteryStatus)objectCasters.GetCaster(typeof(UnityEngine.BatteryStatus))(L, index, null); + } + } + + public void UpdateUnityEngineBatteryStatus(RealStatePtr L, int index, UnityEngine.BatteryStatus val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineBatteryStatus_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.BatteryStatus"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.BatteryStatus ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineUIGraphicRaycasterBlockingObjects_TypeID = -1; + int UnityEngineUIGraphicRaycasterBlockingObjects_EnumRef = -1; + + public void PushUnityEngineUIGraphicRaycasterBlockingObjects(RealStatePtr L, UnityEngine.UI.GraphicRaycaster.BlockingObjects val) + { + if (UnityEngineUIGraphicRaycasterBlockingObjects_TypeID == -1) + { + bool is_first; + UnityEngineUIGraphicRaycasterBlockingObjects_TypeID = getTypeId(L, typeof(UnityEngine.UI.GraphicRaycaster.BlockingObjects), out is_first); + + if (UnityEngineUIGraphicRaycasterBlockingObjects_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.UI.GraphicRaycaster.BlockingObjects)); + UnityEngineUIGraphicRaycasterBlockingObjects_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineUIGraphicRaycasterBlockingObjects_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineUIGraphicRaycasterBlockingObjects_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.UI.GraphicRaycaster.BlockingObjects ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineUIGraphicRaycasterBlockingObjects_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 UnityEngine.UI.GraphicRaycaster.BlockingObjects val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIGraphicRaycasterBlockingObjects_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.GraphicRaycaster.BlockingObjects"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.UI.GraphicRaycaster.BlockingObjects"); + } + val = (UnityEngine.UI.GraphicRaycaster.BlockingObjects)e; + + } + else + { + val = (UnityEngine.UI.GraphicRaycaster.BlockingObjects)objectCasters.GetCaster(typeof(UnityEngine.UI.GraphicRaycaster.BlockingObjects))(L, index, null); + } + } + + public void UpdateUnityEngineUIGraphicRaycasterBlockingObjects(RealStatePtr L, int index, UnityEngine.UI.GraphicRaycaster.BlockingObjects val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIGraphicRaycasterBlockingObjects_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.GraphicRaycaster.BlockingObjects"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.UI.GraphicRaycaster.BlockingObjects ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineUIImageType_TypeID = -1; + int UnityEngineUIImageType_EnumRef = -1; + + public void PushUnityEngineUIImageType(RealStatePtr L, UnityEngine.UI.Image.Type val) + { + if (UnityEngineUIImageType_TypeID == -1) + { + bool is_first; + UnityEngineUIImageType_TypeID = getTypeId(L, typeof(UnityEngine.UI.Image.Type), out is_first); + + if (UnityEngineUIImageType_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.UI.Image.Type)); + UnityEngineUIImageType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineUIImageType_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineUIImageType_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.UI.Image.Type ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineUIImageType_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 UnityEngine.UI.Image.Type val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIImageType_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.Image.Type"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.UI.Image.Type"); + } + val = (UnityEngine.UI.Image.Type)e; + + } + else + { + val = (UnityEngine.UI.Image.Type)objectCasters.GetCaster(typeof(UnityEngine.UI.Image.Type))(L, index, null); + } + } + + public void UpdateUnityEngineUIImageType(RealStatePtr L, int index, UnityEngine.UI.Image.Type val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIImageType_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.Image.Type"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.UI.Image.Type ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineUIImageFillMethod_TypeID = -1; + int UnityEngineUIImageFillMethod_EnumRef = -1; + + public void PushUnityEngineUIImageFillMethod(RealStatePtr L, UnityEngine.UI.Image.FillMethod val) + { + if (UnityEngineUIImageFillMethod_TypeID == -1) + { + bool is_first; + UnityEngineUIImageFillMethod_TypeID = getTypeId(L, typeof(UnityEngine.UI.Image.FillMethod), out is_first); + + if (UnityEngineUIImageFillMethod_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.UI.Image.FillMethod)); + UnityEngineUIImageFillMethod_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineUIImageFillMethod_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineUIImageFillMethod_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.UI.Image.FillMethod ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineUIImageFillMethod_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 UnityEngine.UI.Image.FillMethod val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIImageFillMethod_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.Image.FillMethod"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.UI.Image.FillMethod"); + } + val = (UnityEngine.UI.Image.FillMethod)e; + + } + else + { + val = (UnityEngine.UI.Image.FillMethod)objectCasters.GetCaster(typeof(UnityEngine.UI.Image.FillMethod))(L, index, null); + } + } + + public void UpdateUnityEngineUIImageFillMethod(RealStatePtr L, int index, UnityEngine.UI.Image.FillMethod val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIImageFillMethod_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.Image.FillMethod"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.UI.Image.FillMethod ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineUIImageOriginHorizontal_TypeID = -1; + int UnityEngineUIImageOriginHorizontal_EnumRef = -1; + + public void PushUnityEngineUIImageOriginHorizontal(RealStatePtr L, UnityEngine.UI.Image.OriginHorizontal val) + { + if (UnityEngineUIImageOriginHorizontal_TypeID == -1) + { + bool is_first; + UnityEngineUIImageOriginHorizontal_TypeID = getTypeId(L, typeof(UnityEngine.UI.Image.OriginHorizontal), out is_first); + + if (UnityEngineUIImageOriginHorizontal_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.UI.Image.OriginHorizontal)); + UnityEngineUIImageOriginHorizontal_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineUIImageOriginHorizontal_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineUIImageOriginHorizontal_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.UI.Image.OriginHorizontal ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineUIImageOriginHorizontal_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 UnityEngine.UI.Image.OriginHorizontal val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIImageOriginHorizontal_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.Image.OriginHorizontal"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.UI.Image.OriginHorizontal"); + } + val = (UnityEngine.UI.Image.OriginHorizontal)e; + + } + else + { + val = (UnityEngine.UI.Image.OriginHorizontal)objectCasters.GetCaster(typeof(UnityEngine.UI.Image.OriginHorizontal))(L, index, null); + } + } + + public void UpdateUnityEngineUIImageOriginHorizontal(RealStatePtr L, int index, UnityEngine.UI.Image.OriginHorizontal val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIImageOriginHorizontal_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.Image.OriginHorizontal"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.UI.Image.OriginHorizontal ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineUIImageOriginVertical_TypeID = -1; + int UnityEngineUIImageOriginVertical_EnumRef = -1; + + public void PushUnityEngineUIImageOriginVertical(RealStatePtr L, UnityEngine.UI.Image.OriginVertical val) + { + if (UnityEngineUIImageOriginVertical_TypeID == -1) + { + bool is_first; + UnityEngineUIImageOriginVertical_TypeID = getTypeId(L, typeof(UnityEngine.UI.Image.OriginVertical), out is_first); + + if (UnityEngineUIImageOriginVertical_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.UI.Image.OriginVertical)); + UnityEngineUIImageOriginVertical_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineUIImageOriginVertical_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineUIImageOriginVertical_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.UI.Image.OriginVertical ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineUIImageOriginVertical_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 UnityEngine.UI.Image.OriginVertical val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIImageOriginVertical_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.Image.OriginVertical"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.UI.Image.OriginVertical"); + } + val = (UnityEngine.UI.Image.OriginVertical)e; + + } + else + { + val = (UnityEngine.UI.Image.OriginVertical)objectCasters.GetCaster(typeof(UnityEngine.UI.Image.OriginVertical))(L, index, null); + } + } + + public void UpdateUnityEngineUIImageOriginVertical(RealStatePtr L, int index, UnityEngine.UI.Image.OriginVertical val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIImageOriginVertical_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.Image.OriginVertical"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.UI.Image.OriginVertical ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineUIImageOrigin90_TypeID = -1; + int UnityEngineUIImageOrigin90_EnumRef = -1; + + public void PushUnityEngineUIImageOrigin90(RealStatePtr L, UnityEngine.UI.Image.Origin90 val) + { + if (UnityEngineUIImageOrigin90_TypeID == -1) + { + bool is_first; + UnityEngineUIImageOrigin90_TypeID = getTypeId(L, typeof(UnityEngine.UI.Image.Origin90), out is_first); + + if (UnityEngineUIImageOrigin90_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.UI.Image.Origin90)); + UnityEngineUIImageOrigin90_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineUIImageOrigin90_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineUIImageOrigin90_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.UI.Image.Origin90 ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineUIImageOrigin90_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 UnityEngine.UI.Image.Origin90 val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIImageOrigin90_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.Image.Origin90"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.UI.Image.Origin90"); + } + val = (UnityEngine.UI.Image.Origin90)e; + + } + else + { + val = (UnityEngine.UI.Image.Origin90)objectCasters.GetCaster(typeof(UnityEngine.UI.Image.Origin90))(L, index, null); + } + } + + public void UpdateUnityEngineUIImageOrigin90(RealStatePtr L, int index, UnityEngine.UI.Image.Origin90 val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIImageOrigin90_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.Image.Origin90"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.UI.Image.Origin90 ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineUIImageOrigin180_TypeID = -1; + int UnityEngineUIImageOrigin180_EnumRef = -1; + + public void PushUnityEngineUIImageOrigin180(RealStatePtr L, UnityEngine.UI.Image.Origin180 val) + { + if (UnityEngineUIImageOrigin180_TypeID == -1) + { + bool is_first; + UnityEngineUIImageOrigin180_TypeID = getTypeId(L, typeof(UnityEngine.UI.Image.Origin180), out is_first); + + if (UnityEngineUIImageOrigin180_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.UI.Image.Origin180)); + UnityEngineUIImageOrigin180_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineUIImageOrigin180_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineUIImageOrigin180_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.UI.Image.Origin180 ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineUIImageOrigin180_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 UnityEngine.UI.Image.Origin180 val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIImageOrigin180_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.Image.Origin180"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.UI.Image.Origin180"); + } + val = (UnityEngine.UI.Image.Origin180)e; + + } + else + { + val = (UnityEngine.UI.Image.Origin180)objectCasters.GetCaster(typeof(UnityEngine.UI.Image.Origin180))(L, index, null); + } + } + + public void UpdateUnityEngineUIImageOrigin180(RealStatePtr L, int index, UnityEngine.UI.Image.Origin180 val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIImageOrigin180_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.Image.Origin180"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.UI.Image.Origin180 ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineUIImageOrigin360_TypeID = -1; + int UnityEngineUIImageOrigin360_EnumRef = -1; + + public void PushUnityEngineUIImageOrigin360(RealStatePtr L, UnityEngine.UI.Image.Origin360 val) + { + if (UnityEngineUIImageOrigin360_TypeID == -1) + { + bool is_first; + UnityEngineUIImageOrigin360_TypeID = getTypeId(L, typeof(UnityEngine.UI.Image.Origin360), out is_first); + + if (UnityEngineUIImageOrigin360_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.UI.Image.Origin360)); + UnityEngineUIImageOrigin360_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineUIImageOrigin360_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineUIImageOrigin360_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.UI.Image.Origin360 ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineUIImageOrigin360_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 UnityEngine.UI.Image.Origin360 val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIImageOrigin360_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.Image.Origin360"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.UI.Image.Origin360"); + } + val = (UnityEngine.UI.Image.Origin360)e; + + } + else + { + val = (UnityEngine.UI.Image.Origin360)objectCasters.GetCaster(typeof(UnityEngine.UI.Image.Origin360))(L, index, null); + } + } + + public void UpdateUnityEngineUIImageOrigin360(RealStatePtr L, int index, UnityEngine.UI.Image.Origin360 val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIImageOrigin360_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.Image.Origin360"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.UI.Image.Origin360 ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineUIInputFieldContentType_TypeID = -1; + int UnityEngineUIInputFieldContentType_EnumRef = -1; + + public void PushUnityEngineUIInputFieldContentType(RealStatePtr L, UnityEngine.UI.InputField.ContentType val) + { + if (UnityEngineUIInputFieldContentType_TypeID == -1) + { + bool is_first; + UnityEngineUIInputFieldContentType_TypeID = getTypeId(L, typeof(UnityEngine.UI.InputField.ContentType), out is_first); + + if (UnityEngineUIInputFieldContentType_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.UI.InputField.ContentType)); + UnityEngineUIInputFieldContentType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineUIInputFieldContentType_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineUIInputFieldContentType_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.UI.InputField.ContentType ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineUIInputFieldContentType_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 UnityEngine.UI.InputField.ContentType val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIInputFieldContentType_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.InputField.ContentType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.UI.InputField.ContentType"); + } + val = (UnityEngine.UI.InputField.ContentType)e; + + } + else + { + val = (UnityEngine.UI.InputField.ContentType)objectCasters.GetCaster(typeof(UnityEngine.UI.InputField.ContentType))(L, index, null); + } + } + + public void UpdateUnityEngineUIInputFieldContentType(RealStatePtr L, int index, UnityEngine.UI.InputField.ContentType val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIInputFieldContentType_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.InputField.ContentType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.UI.InputField.ContentType ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineUIInputFieldInputType_TypeID = -1; + int UnityEngineUIInputFieldInputType_EnumRef = -1; + + public void PushUnityEngineUIInputFieldInputType(RealStatePtr L, UnityEngine.UI.InputField.InputType val) + { + if (UnityEngineUIInputFieldInputType_TypeID == -1) + { + bool is_first; + UnityEngineUIInputFieldInputType_TypeID = getTypeId(L, typeof(UnityEngine.UI.InputField.InputType), out is_first); + + if (UnityEngineUIInputFieldInputType_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.UI.InputField.InputType)); + UnityEngineUIInputFieldInputType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineUIInputFieldInputType_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineUIInputFieldInputType_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.UI.InputField.InputType ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineUIInputFieldInputType_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 UnityEngine.UI.InputField.InputType val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIInputFieldInputType_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.InputField.InputType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.UI.InputField.InputType"); + } + val = (UnityEngine.UI.InputField.InputType)e; + + } + else + { + val = (UnityEngine.UI.InputField.InputType)objectCasters.GetCaster(typeof(UnityEngine.UI.InputField.InputType))(L, index, null); + } + } + + public void UpdateUnityEngineUIInputFieldInputType(RealStatePtr L, int index, UnityEngine.UI.InputField.InputType val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIInputFieldInputType_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.InputField.InputType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.UI.InputField.InputType ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineUIInputFieldCharacterValidation_TypeID = -1; + int UnityEngineUIInputFieldCharacterValidation_EnumRef = -1; + + public void PushUnityEngineUIInputFieldCharacterValidation(RealStatePtr L, UnityEngine.UI.InputField.CharacterValidation val) + { + if (UnityEngineUIInputFieldCharacterValidation_TypeID == -1) + { + bool is_first; + UnityEngineUIInputFieldCharacterValidation_TypeID = getTypeId(L, typeof(UnityEngine.UI.InputField.CharacterValidation), out is_first); + + if (UnityEngineUIInputFieldCharacterValidation_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.UI.InputField.CharacterValidation)); + UnityEngineUIInputFieldCharacterValidation_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineUIInputFieldCharacterValidation_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineUIInputFieldCharacterValidation_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.UI.InputField.CharacterValidation ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineUIInputFieldCharacterValidation_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 UnityEngine.UI.InputField.CharacterValidation val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIInputFieldCharacterValidation_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.InputField.CharacterValidation"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.UI.InputField.CharacterValidation"); + } + val = (UnityEngine.UI.InputField.CharacterValidation)e; + + } + else + { + val = (UnityEngine.UI.InputField.CharacterValidation)objectCasters.GetCaster(typeof(UnityEngine.UI.InputField.CharacterValidation))(L, index, null); + } + } + + public void UpdateUnityEngineUIInputFieldCharacterValidation(RealStatePtr L, int index, UnityEngine.UI.InputField.CharacterValidation val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIInputFieldCharacterValidation_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.InputField.CharacterValidation"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.UI.InputField.CharacterValidation ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineUIInputFieldLineType_TypeID = -1; + int UnityEngineUIInputFieldLineType_EnumRef = -1; + + public void PushUnityEngineUIInputFieldLineType(RealStatePtr L, UnityEngine.UI.InputField.LineType val) + { + if (UnityEngineUIInputFieldLineType_TypeID == -1) + { + bool is_first; + UnityEngineUIInputFieldLineType_TypeID = getTypeId(L, typeof(UnityEngine.UI.InputField.LineType), out is_first); + + if (UnityEngineUIInputFieldLineType_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.UI.InputField.LineType)); + UnityEngineUIInputFieldLineType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineUIInputFieldLineType_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineUIInputFieldLineType_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.UI.InputField.LineType ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineUIInputFieldLineType_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 UnityEngine.UI.InputField.LineType val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIInputFieldLineType_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.InputField.LineType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.UI.InputField.LineType"); + } + val = (UnityEngine.UI.InputField.LineType)e; + + } + else + { + val = (UnityEngine.UI.InputField.LineType)objectCasters.GetCaster(typeof(UnityEngine.UI.InputField.LineType))(L, index, null); + } + } + + public void UpdateUnityEngineUIInputFieldLineType(RealStatePtr L, int index, UnityEngine.UI.InputField.LineType val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIInputFieldLineType_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.InputField.LineType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.UI.InputField.LineType ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineUIScrollRectMovementType_TypeID = -1; + int UnityEngineUIScrollRectMovementType_EnumRef = -1; + + public void PushUnityEngineUIScrollRectMovementType(RealStatePtr L, UnityEngine.UI.ScrollRect.MovementType val) + { + if (UnityEngineUIScrollRectMovementType_TypeID == -1) + { + bool is_first; + UnityEngineUIScrollRectMovementType_TypeID = getTypeId(L, typeof(UnityEngine.UI.ScrollRect.MovementType), out is_first); + + if (UnityEngineUIScrollRectMovementType_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.UI.ScrollRect.MovementType)); + UnityEngineUIScrollRectMovementType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineUIScrollRectMovementType_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineUIScrollRectMovementType_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.UI.ScrollRect.MovementType ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineUIScrollRectMovementType_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 UnityEngine.UI.ScrollRect.MovementType val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIScrollRectMovementType_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.ScrollRect.MovementType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.UI.ScrollRect.MovementType"); + } + val = (UnityEngine.UI.ScrollRect.MovementType)e; + + } + else + { + val = (UnityEngine.UI.ScrollRect.MovementType)objectCasters.GetCaster(typeof(UnityEngine.UI.ScrollRect.MovementType))(L, index, null); + } + } + + public void UpdateUnityEngineUIScrollRectMovementType(RealStatePtr L, int index, UnityEngine.UI.ScrollRect.MovementType val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIScrollRectMovementType_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.ScrollRect.MovementType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.UI.ScrollRect.MovementType ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineUIScrollRectScrollbarVisibility_TypeID = -1; + int UnityEngineUIScrollRectScrollbarVisibility_EnumRef = -1; + + public void PushUnityEngineUIScrollRectScrollbarVisibility(RealStatePtr L, UnityEngine.UI.ScrollRect.ScrollbarVisibility val) + { + if (UnityEngineUIScrollRectScrollbarVisibility_TypeID == -1) + { + bool is_first; + UnityEngineUIScrollRectScrollbarVisibility_TypeID = getTypeId(L, typeof(UnityEngine.UI.ScrollRect.ScrollbarVisibility), out is_first); + + if (UnityEngineUIScrollRectScrollbarVisibility_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.UI.ScrollRect.ScrollbarVisibility)); + UnityEngineUIScrollRectScrollbarVisibility_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineUIScrollRectScrollbarVisibility_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineUIScrollRectScrollbarVisibility_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.UI.ScrollRect.ScrollbarVisibility ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineUIScrollRectScrollbarVisibility_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 UnityEngine.UI.ScrollRect.ScrollbarVisibility val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIScrollRectScrollbarVisibility_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.ScrollRect.ScrollbarVisibility"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.UI.ScrollRect.ScrollbarVisibility"); + } + val = (UnityEngine.UI.ScrollRect.ScrollbarVisibility)e; + + } + else + { + val = (UnityEngine.UI.ScrollRect.ScrollbarVisibility)objectCasters.GetCaster(typeof(UnityEngine.UI.ScrollRect.ScrollbarVisibility))(L, index, null); + } + } + + public void UpdateUnityEngineUIScrollRectScrollbarVisibility(RealStatePtr L, int index, UnityEngine.UI.ScrollRect.ScrollbarVisibility val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIScrollRectScrollbarVisibility_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.ScrollRect.ScrollbarVisibility"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.UI.ScrollRect.ScrollbarVisibility ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineUISliderDirection_TypeID = -1; + int UnityEngineUISliderDirection_EnumRef = -1; + + public void PushUnityEngineUISliderDirection(RealStatePtr L, UnityEngine.UI.Slider.Direction val) + { + if (UnityEngineUISliderDirection_TypeID == -1) + { + bool is_first; + UnityEngineUISliderDirection_TypeID = getTypeId(L, typeof(UnityEngine.UI.Slider.Direction), out is_first); + + if (UnityEngineUISliderDirection_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.UI.Slider.Direction)); + UnityEngineUISliderDirection_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineUISliderDirection_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineUISliderDirection_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.UI.Slider.Direction ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineUISliderDirection_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 UnityEngine.UI.Slider.Direction val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUISliderDirection_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.Slider.Direction"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.UI.Slider.Direction"); + } + val = (UnityEngine.UI.Slider.Direction)e; + + } + else + { + val = (UnityEngine.UI.Slider.Direction)objectCasters.GetCaster(typeof(UnityEngine.UI.Slider.Direction))(L, index, null); + } + } + + public void UpdateUnityEngineUISliderDirection(RealStatePtr L, int index, UnityEngine.UI.Slider.Direction val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUISliderDirection_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.Slider.Direction"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.UI.Slider.Direction ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineUIToggleToggleTransition_TypeID = -1; + int UnityEngineUIToggleToggleTransition_EnumRef = -1; + + public void PushUnityEngineUIToggleToggleTransition(RealStatePtr L, UnityEngine.UI.Toggle.ToggleTransition val) + { + if (UnityEngineUIToggleToggleTransition_TypeID == -1) + { + bool is_first; + UnityEngineUIToggleToggleTransition_TypeID = getTypeId(L, typeof(UnityEngine.UI.Toggle.ToggleTransition), out is_first); + + if (UnityEngineUIToggleToggleTransition_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.UI.Toggle.ToggleTransition)); + UnityEngineUIToggleToggleTransition_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineUIToggleToggleTransition_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineUIToggleToggleTransition_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.UI.Toggle.ToggleTransition ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineUIToggleToggleTransition_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 UnityEngine.UI.Toggle.ToggleTransition val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIToggleToggleTransition_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.Toggle.ToggleTransition"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.UI.Toggle.ToggleTransition"); + } + val = (UnityEngine.UI.Toggle.ToggleTransition)e; + + } + else + { + val = (UnityEngine.UI.Toggle.ToggleTransition)objectCasters.GetCaster(typeof(UnityEngine.UI.Toggle.ToggleTransition))(L, index, null); + } + } + + public void UpdateUnityEngineUIToggleToggleTransition(RealStatePtr L, int index, UnityEngine.UI.Toggle.ToggleTransition val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIToggleToggleTransition_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.Toggle.ToggleTransition"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.UI.Toggle.ToggleTransition ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineUIGridLayoutGroupCorner_TypeID = -1; + int UnityEngineUIGridLayoutGroupCorner_EnumRef = -1; + + public void PushUnityEngineUIGridLayoutGroupCorner(RealStatePtr L, UnityEngine.UI.GridLayoutGroup.Corner val) + { + if (UnityEngineUIGridLayoutGroupCorner_TypeID == -1) + { + bool is_first; + UnityEngineUIGridLayoutGroupCorner_TypeID = getTypeId(L, typeof(UnityEngine.UI.GridLayoutGroup.Corner), out is_first); + + if (UnityEngineUIGridLayoutGroupCorner_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.UI.GridLayoutGroup.Corner)); + UnityEngineUIGridLayoutGroupCorner_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineUIGridLayoutGroupCorner_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineUIGridLayoutGroupCorner_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.UI.GridLayoutGroup.Corner ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineUIGridLayoutGroupCorner_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 UnityEngine.UI.GridLayoutGroup.Corner val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIGridLayoutGroupCorner_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.GridLayoutGroup.Corner"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.UI.GridLayoutGroup.Corner"); + } + val = (UnityEngine.UI.GridLayoutGroup.Corner)e; + + } + else + { + val = (UnityEngine.UI.GridLayoutGroup.Corner)objectCasters.GetCaster(typeof(UnityEngine.UI.GridLayoutGroup.Corner))(L, index, null); + } + } + + public void UpdateUnityEngineUIGridLayoutGroupCorner(RealStatePtr L, int index, UnityEngine.UI.GridLayoutGroup.Corner val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIGridLayoutGroupCorner_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.GridLayoutGroup.Corner"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.UI.GridLayoutGroup.Corner ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineUIGridLayoutGroupAxis_TypeID = -1; + int UnityEngineUIGridLayoutGroupAxis_EnumRef = -1; + + public void PushUnityEngineUIGridLayoutGroupAxis(RealStatePtr L, UnityEngine.UI.GridLayoutGroup.Axis val) + { + if (UnityEngineUIGridLayoutGroupAxis_TypeID == -1) + { + bool is_first; + UnityEngineUIGridLayoutGroupAxis_TypeID = getTypeId(L, typeof(UnityEngine.UI.GridLayoutGroup.Axis), out is_first); + + if (UnityEngineUIGridLayoutGroupAxis_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.UI.GridLayoutGroup.Axis)); + UnityEngineUIGridLayoutGroupAxis_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineUIGridLayoutGroupAxis_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineUIGridLayoutGroupAxis_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.UI.GridLayoutGroup.Axis ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineUIGridLayoutGroupAxis_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 UnityEngine.UI.GridLayoutGroup.Axis val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIGridLayoutGroupAxis_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.GridLayoutGroup.Axis"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.UI.GridLayoutGroup.Axis"); + } + val = (UnityEngine.UI.GridLayoutGroup.Axis)e; + + } + else + { + val = (UnityEngine.UI.GridLayoutGroup.Axis)objectCasters.GetCaster(typeof(UnityEngine.UI.GridLayoutGroup.Axis))(L, index, null); + } + } + + public void UpdateUnityEngineUIGridLayoutGroupAxis(RealStatePtr L, int index, UnityEngine.UI.GridLayoutGroup.Axis val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIGridLayoutGroupAxis_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.GridLayoutGroup.Axis"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.UI.GridLayoutGroup.Axis ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEngineUIGridLayoutGroupConstraint_TypeID = -1; + int UnityEngineUIGridLayoutGroupConstraint_EnumRef = -1; + + public void PushUnityEngineUIGridLayoutGroupConstraint(RealStatePtr L, UnityEngine.UI.GridLayoutGroup.Constraint val) + { + if (UnityEngineUIGridLayoutGroupConstraint_TypeID == -1) + { + bool is_first; + UnityEngineUIGridLayoutGroupConstraint_TypeID = getTypeId(L, typeof(UnityEngine.UI.GridLayoutGroup.Constraint), out is_first); + + if (UnityEngineUIGridLayoutGroupConstraint_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.UI.GridLayoutGroup.Constraint)); + UnityEngineUIGridLayoutGroupConstraint_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEngineUIGridLayoutGroupConstraint_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEngineUIGridLayoutGroupConstraint_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.UI.GridLayoutGroup.Constraint ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEngineUIGridLayoutGroupConstraint_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 UnityEngine.UI.GridLayoutGroup.Constraint val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIGridLayoutGroupConstraint_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.GridLayoutGroup.Constraint"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.UI.GridLayoutGroup.Constraint"); + } + val = (UnityEngine.UI.GridLayoutGroup.Constraint)e; + + } + else + { + val = (UnityEngine.UI.GridLayoutGroup.Constraint)objectCasters.GetCaster(typeof(UnityEngine.UI.GridLayoutGroup.Constraint))(L, index, null); + } + } + + public void UpdateUnityEngineUIGridLayoutGroupConstraint(RealStatePtr L, int index, UnityEngine.UI.GridLayoutGroup.Constraint val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineUIGridLayoutGroupConstraint_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.UI.GridLayoutGroup.Constraint"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.UI.GridLayoutGroup.Constraint ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int SpineUnityBoneFollowerAxisOrientation_TypeID = -1; + int SpineUnityBoneFollowerAxisOrientation_EnumRef = -1; + + public void PushSpineUnityBoneFollowerAxisOrientation(RealStatePtr L, Spine.Unity.BoneFollower.AxisOrientation val) + { + if (SpineUnityBoneFollowerAxisOrientation_TypeID == -1) + { + bool is_first; + SpineUnityBoneFollowerAxisOrientation_TypeID = getTypeId(L, typeof(Spine.Unity.BoneFollower.AxisOrientation), out is_first); + + if (SpineUnityBoneFollowerAxisOrientation_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(Spine.Unity.BoneFollower.AxisOrientation)); + SpineUnityBoneFollowerAxisOrientation_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, SpineUnityBoneFollowerAxisOrientation_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, SpineUnityBoneFollowerAxisOrientation_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for Spine.Unity.BoneFollower.AxisOrientation ,value="+val); + } + + LuaAPI.lua_getref(L, SpineUnityBoneFollowerAxisOrientation_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 Spine.Unity.BoneFollower.AxisOrientation val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != SpineUnityBoneFollowerAxisOrientation_TypeID) + { + throw new Exception("invalid userdata for Spine.Unity.BoneFollower.AxisOrientation"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for Spine.Unity.BoneFollower.AxisOrientation"); + } + val = (Spine.Unity.BoneFollower.AxisOrientation)e; + + } + else + { + val = (Spine.Unity.BoneFollower.AxisOrientation)objectCasters.GetCaster(typeof(Spine.Unity.BoneFollower.AxisOrientation))(L, index, null); + } + } + + public void UpdateSpineUnityBoneFollowerAxisOrientation(RealStatePtr L, int index, Spine.Unity.BoneFollower.AxisOrientation val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != SpineUnityBoneFollowerAxisOrientation_TypeID) + { + throw new Exception("invalid userdata for Spine.Unity.BoneFollower.AxisOrientation"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for Spine.Unity.BoneFollower.AxisOrientation ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int SpineUnitySkeletonGraphicLayoutMode_TypeID = -1; + int SpineUnitySkeletonGraphicLayoutMode_EnumRef = -1; + + public void PushSpineUnitySkeletonGraphicLayoutMode(RealStatePtr L, Spine.Unity.SkeletonGraphic.LayoutMode val) + { + if (SpineUnitySkeletonGraphicLayoutMode_TypeID == -1) + { + bool is_first; + SpineUnitySkeletonGraphicLayoutMode_TypeID = getTypeId(L, typeof(Spine.Unity.SkeletonGraphic.LayoutMode), out is_first); + + if (SpineUnitySkeletonGraphicLayoutMode_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(Spine.Unity.SkeletonGraphic.LayoutMode)); + SpineUnitySkeletonGraphicLayoutMode_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, SpineUnitySkeletonGraphicLayoutMode_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, SpineUnitySkeletonGraphicLayoutMode_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for Spine.Unity.SkeletonGraphic.LayoutMode ,value="+val); + } + + LuaAPI.lua_getref(L, SpineUnitySkeletonGraphicLayoutMode_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 Spine.Unity.SkeletonGraphic.LayoutMode val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != SpineUnitySkeletonGraphicLayoutMode_TypeID) + { + throw new Exception("invalid userdata for Spine.Unity.SkeletonGraphic.LayoutMode"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for Spine.Unity.SkeletonGraphic.LayoutMode"); + } + val = (Spine.Unity.SkeletonGraphic.LayoutMode)e; + + } + else + { + val = (Spine.Unity.SkeletonGraphic.LayoutMode)objectCasters.GetCaster(typeof(Spine.Unity.SkeletonGraphic.LayoutMode))(L, index, null); + } + } + + public void UpdateSpineUnitySkeletonGraphicLayoutMode(RealStatePtr L, int index, Spine.Unity.SkeletonGraphic.LayoutMode val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != SpineUnitySkeletonGraphicLayoutMode_TypeID) + { + throw new Exception("invalid userdata for Spine.Unity.SkeletonGraphic.LayoutMode"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for Spine.Unity.SkeletonGraphic.LayoutMode ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int TMProTextAlignmentOptions_TypeID = -1; + int TMProTextAlignmentOptions_EnumRef = -1; + + public void PushTMProTextAlignmentOptions(RealStatePtr L, TMPro.TextAlignmentOptions val) + { + if (TMProTextAlignmentOptions_TypeID == -1) + { + bool is_first; + TMProTextAlignmentOptions_TypeID = getTypeId(L, typeof(TMPro.TextAlignmentOptions), out is_first); + + if (TMProTextAlignmentOptions_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(TMPro.TextAlignmentOptions)); + TMProTextAlignmentOptions_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, TMProTextAlignmentOptions_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, TMProTextAlignmentOptions_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for TMPro.TextAlignmentOptions ,value="+val); + } + + LuaAPI.lua_getref(L, TMProTextAlignmentOptions_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 TMPro.TextAlignmentOptions val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != TMProTextAlignmentOptions_TypeID) + { + throw new Exception("invalid userdata for TMPro.TextAlignmentOptions"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for TMPro.TextAlignmentOptions"); + } + val = (TMPro.TextAlignmentOptions)e; + + } + else + { + val = (TMPro.TextAlignmentOptions)objectCasters.GetCaster(typeof(TMPro.TextAlignmentOptions))(L, index, null); + } + } + + public void UpdateTMProTextAlignmentOptions(RealStatePtr L, int index, TMPro.TextAlignmentOptions val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != TMProTextAlignmentOptions_TypeID) + { + throw new Exception("invalid userdata for TMPro.TextAlignmentOptions"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for TMPro.TextAlignmentOptions ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int TMProTMP_InputFieldContentType_TypeID = -1; + int TMProTMP_InputFieldContentType_EnumRef = -1; + + public void PushTMProTMP_InputFieldContentType(RealStatePtr L, TMPro.TMP_InputField.ContentType val) + { + if (TMProTMP_InputFieldContentType_TypeID == -1) + { + bool is_first; + TMProTMP_InputFieldContentType_TypeID = getTypeId(L, typeof(TMPro.TMP_InputField.ContentType), out is_first); + + if (TMProTMP_InputFieldContentType_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(TMPro.TMP_InputField.ContentType)); + TMProTMP_InputFieldContentType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, TMProTMP_InputFieldContentType_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, TMProTMP_InputFieldContentType_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for TMPro.TMP_InputField.ContentType ,value="+val); + } + + LuaAPI.lua_getref(L, TMProTMP_InputFieldContentType_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 TMPro.TMP_InputField.ContentType val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != TMProTMP_InputFieldContentType_TypeID) + { + throw new Exception("invalid userdata for TMPro.TMP_InputField.ContentType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for TMPro.TMP_InputField.ContentType"); + } + val = (TMPro.TMP_InputField.ContentType)e; + + } + else + { + val = (TMPro.TMP_InputField.ContentType)objectCasters.GetCaster(typeof(TMPro.TMP_InputField.ContentType))(L, index, null); + } + } + + public void UpdateTMProTMP_InputFieldContentType(RealStatePtr L, int index, TMPro.TMP_InputField.ContentType val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != TMProTMP_InputFieldContentType_TypeID) + { + throw new Exception("invalid userdata for TMPro.TMP_InputField.ContentType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for TMPro.TMP_InputField.ContentType ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int TMProTMP_InputFieldInputType_TypeID = -1; + int TMProTMP_InputFieldInputType_EnumRef = -1; + + public void PushTMProTMP_InputFieldInputType(RealStatePtr L, TMPro.TMP_InputField.InputType val) + { + if (TMProTMP_InputFieldInputType_TypeID == -1) + { + bool is_first; + TMProTMP_InputFieldInputType_TypeID = getTypeId(L, typeof(TMPro.TMP_InputField.InputType), out is_first); + + if (TMProTMP_InputFieldInputType_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(TMPro.TMP_InputField.InputType)); + TMProTMP_InputFieldInputType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, TMProTMP_InputFieldInputType_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, TMProTMP_InputFieldInputType_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for TMPro.TMP_InputField.InputType ,value="+val); + } + + LuaAPI.lua_getref(L, TMProTMP_InputFieldInputType_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 TMPro.TMP_InputField.InputType val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != TMProTMP_InputFieldInputType_TypeID) + { + throw new Exception("invalid userdata for TMPro.TMP_InputField.InputType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for TMPro.TMP_InputField.InputType"); + } + val = (TMPro.TMP_InputField.InputType)e; + + } + else + { + val = (TMPro.TMP_InputField.InputType)objectCasters.GetCaster(typeof(TMPro.TMP_InputField.InputType))(L, index, null); + } + } + + public void UpdateTMProTMP_InputFieldInputType(RealStatePtr L, int index, TMPro.TMP_InputField.InputType val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != TMProTMP_InputFieldInputType_TypeID) + { + throw new Exception("invalid userdata for TMPro.TMP_InputField.InputType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for TMPro.TMP_InputField.InputType ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int TMProTMP_InputFieldCharacterValidation_TypeID = -1; + int TMProTMP_InputFieldCharacterValidation_EnumRef = -1; + + public void PushTMProTMP_InputFieldCharacterValidation(RealStatePtr L, TMPro.TMP_InputField.CharacterValidation val) + { + if (TMProTMP_InputFieldCharacterValidation_TypeID == -1) + { + bool is_first; + TMProTMP_InputFieldCharacterValidation_TypeID = getTypeId(L, typeof(TMPro.TMP_InputField.CharacterValidation), out is_first); + + if (TMProTMP_InputFieldCharacterValidation_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(TMPro.TMP_InputField.CharacterValidation)); + TMProTMP_InputFieldCharacterValidation_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, TMProTMP_InputFieldCharacterValidation_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, TMProTMP_InputFieldCharacterValidation_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for TMPro.TMP_InputField.CharacterValidation ,value="+val); + } + + LuaAPI.lua_getref(L, TMProTMP_InputFieldCharacterValidation_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 TMPro.TMP_InputField.CharacterValidation val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != TMProTMP_InputFieldCharacterValidation_TypeID) + { + throw new Exception("invalid userdata for TMPro.TMP_InputField.CharacterValidation"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for TMPro.TMP_InputField.CharacterValidation"); + } + val = (TMPro.TMP_InputField.CharacterValidation)e; + + } + else + { + val = (TMPro.TMP_InputField.CharacterValidation)objectCasters.GetCaster(typeof(TMPro.TMP_InputField.CharacterValidation))(L, index, null); + } + } + + public void UpdateTMProTMP_InputFieldCharacterValidation(RealStatePtr L, int index, TMPro.TMP_InputField.CharacterValidation val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != TMProTMP_InputFieldCharacterValidation_TypeID) + { + throw new Exception("invalid userdata for TMPro.TMP_InputField.CharacterValidation"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for TMPro.TMP_InputField.CharacterValidation ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int TMProTMP_InputFieldLineType_TypeID = -1; + int TMProTMP_InputFieldLineType_EnumRef = -1; + + public void PushTMProTMP_InputFieldLineType(RealStatePtr L, TMPro.TMP_InputField.LineType val) + { + if (TMProTMP_InputFieldLineType_TypeID == -1) + { + bool is_first; + TMProTMP_InputFieldLineType_TypeID = getTypeId(L, typeof(TMPro.TMP_InputField.LineType), out is_first); + + if (TMProTMP_InputFieldLineType_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(TMPro.TMP_InputField.LineType)); + TMProTMP_InputFieldLineType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, TMProTMP_InputFieldLineType_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, TMProTMP_InputFieldLineType_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for TMPro.TMP_InputField.LineType ,value="+val); + } + + LuaAPI.lua_getref(L, TMProTMP_InputFieldLineType_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 TMPro.TMP_InputField.LineType val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != TMProTMP_InputFieldLineType_TypeID) + { + throw new Exception("invalid userdata for TMPro.TMP_InputField.LineType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for TMPro.TMP_InputField.LineType"); + } + val = (TMPro.TMP_InputField.LineType)e; + + } + else + { + val = (TMPro.TMP_InputField.LineType)objectCasters.GetCaster(typeof(TMPro.TMP_InputField.LineType))(L, index, null); + } + } + + public void UpdateTMProTMP_InputFieldLineType(RealStatePtr L, int index, TMPro.TMP_InputField.LineType val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != TMProTMP_InputFieldLineType_TypeID) + { + throw new Exception("invalid userdata for TMPro.TMP_InputField.LineType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for TMPro.TMP_InputField.LineType ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int ThinkingAnalyticsThinkingAnalyticsAPITATimeZone_TypeID = -1; + int ThinkingAnalyticsThinkingAnalyticsAPITATimeZone_EnumRef = -1; + + public void PushThinkingAnalyticsThinkingAnalyticsAPITATimeZone(RealStatePtr L, ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone val) + { + if (ThinkingAnalyticsThinkingAnalyticsAPITATimeZone_TypeID == -1) + { + bool is_first; + ThinkingAnalyticsThinkingAnalyticsAPITATimeZone_TypeID = getTypeId(L, typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone), out is_first); + + if (ThinkingAnalyticsThinkingAnalyticsAPITATimeZone_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone)); + ThinkingAnalyticsThinkingAnalyticsAPITATimeZone_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, ThinkingAnalyticsThinkingAnalyticsAPITATimeZone_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, ThinkingAnalyticsThinkingAnalyticsAPITATimeZone_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone ,value="+val); + } + + LuaAPI.lua_getref(L, ThinkingAnalyticsThinkingAnalyticsAPITATimeZone_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 ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != ThinkingAnalyticsThinkingAnalyticsAPITATimeZone_TypeID) + { + throw new Exception("invalid userdata for ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone"); + } + val = (ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone)e; + + } + else + { + val = (ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone)objectCasters.GetCaster(typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone))(L, index, null); + } + } + + public void UpdateThinkingAnalyticsThinkingAnalyticsAPITATimeZone(RealStatePtr L, int index, ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != ThinkingAnalyticsThinkingAnalyticsAPITATimeZone_TypeID) + { + throw new Exception("invalid userdata for ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int ThinkingAnalyticsThinkingAnalyticsAPITAMode_TypeID = -1; + int ThinkingAnalyticsThinkingAnalyticsAPITAMode_EnumRef = -1; + + public void PushThinkingAnalyticsThinkingAnalyticsAPITAMode(RealStatePtr L, ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode val) + { + if (ThinkingAnalyticsThinkingAnalyticsAPITAMode_TypeID == -1) + { + bool is_first; + ThinkingAnalyticsThinkingAnalyticsAPITAMode_TypeID = getTypeId(L, typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode), out is_first); + + if (ThinkingAnalyticsThinkingAnalyticsAPITAMode_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode)); + ThinkingAnalyticsThinkingAnalyticsAPITAMode_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, ThinkingAnalyticsThinkingAnalyticsAPITAMode_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, ThinkingAnalyticsThinkingAnalyticsAPITAMode_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode ,value="+val); + } + + LuaAPI.lua_getref(L, ThinkingAnalyticsThinkingAnalyticsAPITAMode_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 ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != ThinkingAnalyticsThinkingAnalyticsAPITAMode_TypeID) + { + throw new Exception("invalid userdata for ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode"); + } + val = (ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode)e; + + } + else + { + val = (ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode)objectCasters.GetCaster(typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode))(L, index, null); + } + } + + public void UpdateThinkingAnalyticsThinkingAnalyticsAPITAMode(RealStatePtr L, int index, ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != ThinkingAnalyticsThinkingAnalyticsAPITAMode_TypeID) + { + throw new Exception("invalid userdata for ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int ThinkingAnalyticsThinkingAnalyticsAPINetworkType_TypeID = -1; + int ThinkingAnalyticsThinkingAnalyticsAPINetworkType_EnumRef = -1; + + public void PushThinkingAnalyticsThinkingAnalyticsAPINetworkType(RealStatePtr L, ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType val) + { + if (ThinkingAnalyticsThinkingAnalyticsAPINetworkType_TypeID == -1) + { + bool is_first; + ThinkingAnalyticsThinkingAnalyticsAPINetworkType_TypeID = getTypeId(L, typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType), out is_first); + + if (ThinkingAnalyticsThinkingAnalyticsAPINetworkType_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType)); + ThinkingAnalyticsThinkingAnalyticsAPINetworkType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, ThinkingAnalyticsThinkingAnalyticsAPINetworkType_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, ThinkingAnalyticsThinkingAnalyticsAPINetworkType_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType ,value="+val); + } + + LuaAPI.lua_getref(L, ThinkingAnalyticsThinkingAnalyticsAPINetworkType_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 ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != ThinkingAnalyticsThinkingAnalyticsAPINetworkType_TypeID) + { + throw new Exception("invalid userdata for ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType"); + } + val = (ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType)e; + + } + else + { + val = (ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType)objectCasters.GetCaster(typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType))(L, index, null); + } + } + + public void UpdateThinkingAnalyticsThinkingAnalyticsAPINetworkType(RealStatePtr L, int index, ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != ThinkingAnalyticsThinkingAnalyticsAPINetworkType_TypeID) + { + throw new Exception("invalid userdata for ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int DGTweeningAutoPlay_TypeID = -1; + int DGTweeningAutoPlay_EnumRef = -1; + + public void PushDGTweeningAutoPlay(RealStatePtr L, DG.Tweening.AutoPlay val) + { + if (DGTweeningAutoPlay_TypeID == -1) + { + bool is_first; + DGTweeningAutoPlay_TypeID = getTypeId(L, typeof(DG.Tweening.AutoPlay), out is_first); + + if (DGTweeningAutoPlay_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(DG.Tweening.AutoPlay)); + DGTweeningAutoPlay_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, DGTweeningAutoPlay_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, DGTweeningAutoPlay_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for DG.Tweening.AutoPlay ,value="+val); + } + + LuaAPI.lua_getref(L, DGTweeningAutoPlay_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 DG.Tweening.AutoPlay val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != DGTweeningAutoPlay_TypeID) + { + throw new Exception("invalid userdata for DG.Tweening.AutoPlay"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for DG.Tweening.AutoPlay"); + } + val = (DG.Tweening.AutoPlay)e; + + } + else + { + val = (DG.Tweening.AutoPlay)objectCasters.GetCaster(typeof(DG.Tweening.AutoPlay))(L, index, null); + } + } + + public void UpdateDGTweeningAutoPlay(RealStatePtr L, int index, DG.Tweening.AutoPlay val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != DGTweeningAutoPlay_TypeID) + { + throw new Exception("invalid userdata for DG.Tweening.AutoPlay"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for DG.Tweening.AutoPlay ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int DGTweeningAxisConstraint_TypeID = -1; + int DGTweeningAxisConstraint_EnumRef = -1; + + public void PushDGTweeningAxisConstraint(RealStatePtr L, DG.Tweening.AxisConstraint val) + { + if (DGTweeningAxisConstraint_TypeID == -1) + { + bool is_first; + DGTweeningAxisConstraint_TypeID = getTypeId(L, typeof(DG.Tweening.AxisConstraint), out is_first); + + if (DGTweeningAxisConstraint_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(DG.Tweening.AxisConstraint)); + DGTweeningAxisConstraint_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, DGTweeningAxisConstraint_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, DGTweeningAxisConstraint_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for DG.Tweening.AxisConstraint ,value="+val); + } + + LuaAPI.lua_getref(L, DGTweeningAxisConstraint_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 DG.Tweening.AxisConstraint val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != DGTweeningAxisConstraint_TypeID) + { + throw new Exception("invalid userdata for DG.Tweening.AxisConstraint"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for DG.Tweening.AxisConstraint"); + } + val = (DG.Tweening.AxisConstraint)e; + + } + else + { + val = (DG.Tweening.AxisConstraint)objectCasters.GetCaster(typeof(DG.Tweening.AxisConstraint))(L, index, null); + } + } + + public void UpdateDGTweeningAxisConstraint(RealStatePtr L, int index, DG.Tweening.AxisConstraint val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != DGTweeningAxisConstraint_TypeID) + { + throw new Exception("invalid userdata for DG.Tweening.AxisConstraint"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for DG.Tweening.AxisConstraint ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int DGTweeningEase_TypeID = -1; + int DGTweeningEase_EnumRef = -1; + + public void PushDGTweeningEase(RealStatePtr L, DG.Tweening.Ease val) + { + if (DGTweeningEase_TypeID == -1) + { + bool is_first; + DGTweeningEase_TypeID = getTypeId(L, typeof(DG.Tweening.Ease), out is_first); + + if (DGTweeningEase_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(DG.Tweening.Ease)); + DGTweeningEase_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, DGTweeningEase_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, DGTweeningEase_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for DG.Tweening.Ease ,value="+val); + } + + LuaAPI.lua_getref(L, DGTweeningEase_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 DG.Tweening.Ease val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != DGTweeningEase_TypeID) + { + throw new Exception("invalid userdata for DG.Tweening.Ease"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for DG.Tweening.Ease"); + } + val = (DG.Tweening.Ease)e; + + } + else + { + val = (DG.Tweening.Ease)objectCasters.GetCaster(typeof(DG.Tweening.Ease))(L, index, null); + } + } + + public void UpdateDGTweeningEase(RealStatePtr L, int index, DG.Tweening.Ease val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != DGTweeningEase_TypeID) + { + throw new Exception("invalid userdata for DG.Tweening.Ease"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for DG.Tweening.Ease ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int DGTweeningLogBehaviour_TypeID = -1; + int DGTweeningLogBehaviour_EnumRef = -1; + + public void PushDGTweeningLogBehaviour(RealStatePtr L, DG.Tweening.LogBehaviour val) + { + if (DGTweeningLogBehaviour_TypeID == -1) + { + bool is_first; + DGTweeningLogBehaviour_TypeID = getTypeId(L, typeof(DG.Tweening.LogBehaviour), out is_first); + + if (DGTweeningLogBehaviour_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(DG.Tweening.LogBehaviour)); + DGTweeningLogBehaviour_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, DGTweeningLogBehaviour_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, DGTweeningLogBehaviour_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for DG.Tweening.LogBehaviour ,value="+val); + } + + LuaAPI.lua_getref(L, DGTweeningLogBehaviour_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 DG.Tweening.LogBehaviour val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != DGTweeningLogBehaviour_TypeID) + { + throw new Exception("invalid userdata for DG.Tweening.LogBehaviour"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for DG.Tweening.LogBehaviour"); + } + val = (DG.Tweening.LogBehaviour)e; + + } + else + { + val = (DG.Tweening.LogBehaviour)objectCasters.GetCaster(typeof(DG.Tweening.LogBehaviour))(L, index, null); + } + } + + public void UpdateDGTweeningLogBehaviour(RealStatePtr L, int index, DG.Tweening.LogBehaviour val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != DGTweeningLogBehaviour_TypeID) + { + throw new Exception("invalid userdata for DG.Tweening.LogBehaviour"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for DG.Tweening.LogBehaviour ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int DGTweeningLoopType_TypeID = -1; + int DGTweeningLoopType_EnumRef = -1; + + public void PushDGTweeningLoopType(RealStatePtr L, DG.Tweening.LoopType val) + { + if (DGTweeningLoopType_TypeID == -1) + { + bool is_first; + DGTweeningLoopType_TypeID = getTypeId(L, typeof(DG.Tweening.LoopType), out is_first); + + if (DGTweeningLoopType_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(DG.Tweening.LoopType)); + DGTweeningLoopType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, DGTweeningLoopType_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, DGTweeningLoopType_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for DG.Tweening.LoopType ,value="+val); + } + + LuaAPI.lua_getref(L, DGTweeningLoopType_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 DG.Tweening.LoopType val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != DGTweeningLoopType_TypeID) + { + throw new Exception("invalid userdata for DG.Tweening.LoopType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for DG.Tweening.LoopType"); + } + val = (DG.Tweening.LoopType)e; + + } + else + { + val = (DG.Tweening.LoopType)objectCasters.GetCaster(typeof(DG.Tweening.LoopType))(L, index, null); + } + } + + public void UpdateDGTweeningLoopType(RealStatePtr L, int index, DG.Tweening.LoopType val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != DGTweeningLoopType_TypeID) + { + throw new Exception("invalid userdata for DG.Tweening.LoopType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for DG.Tweening.LoopType ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int DGTweeningPathMode_TypeID = -1; + int DGTweeningPathMode_EnumRef = -1; + + public void PushDGTweeningPathMode(RealStatePtr L, DG.Tweening.PathMode val) + { + if (DGTweeningPathMode_TypeID == -1) + { + bool is_first; + DGTweeningPathMode_TypeID = getTypeId(L, typeof(DG.Tweening.PathMode), out is_first); + + if (DGTweeningPathMode_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(DG.Tweening.PathMode)); + DGTweeningPathMode_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, DGTweeningPathMode_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, DGTweeningPathMode_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for DG.Tweening.PathMode ,value="+val); + } + + LuaAPI.lua_getref(L, DGTweeningPathMode_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 DG.Tweening.PathMode val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != DGTweeningPathMode_TypeID) + { + throw new Exception("invalid userdata for DG.Tweening.PathMode"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for DG.Tweening.PathMode"); + } + val = (DG.Tweening.PathMode)e; + + } + else + { + val = (DG.Tweening.PathMode)objectCasters.GetCaster(typeof(DG.Tweening.PathMode))(L, index, null); + } + } + + public void UpdateDGTweeningPathMode(RealStatePtr L, int index, DG.Tweening.PathMode val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != DGTweeningPathMode_TypeID) + { + throw new Exception("invalid userdata for DG.Tweening.PathMode"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for DG.Tweening.PathMode ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int DGTweeningPathType_TypeID = -1; + int DGTweeningPathType_EnumRef = -1; + + public void PushDGTweeningPathType(RealStatePtr L, DG.Tweening.PathType val) + { + if (DGTweeningPathType_TypeID == -1) + { + bool is_first; + DGTweeningPathType_TypeID = getTypeId(L, typeof(DG.Tweening.PathType), out is_first); + + if (DGTweeningPathType_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(DG.Tweening.PathType)); + DGTweeningPathType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, DGTweeningPathType_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, DGTweeningPathType_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for DG.Tweening.PathType ,value="+val); + } + + LuaAPI.lua_getref(L, DGTweeningPathType_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 DG.Tweening.PathType val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != DGTweeningPathType_TypeID) + { + throw new Exception("invalid userdata for DG.Tweening.PathType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for DG.Tweening.PathType"); + } + val = (DG.Tweening.PathType)e; + + } + else + { + val = (DG.Tweening.PathType)objectCasters.GetCaster(typeof(DG.Tweening.PathType))(L, index, null); + } + } + + public void UpdateDGTweeningPathType(RealStatePtr L, int index, DG.Tweening.PathType val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != DGTweeningPathType_TypeID) + { + throw new Exception("invalid userdata for DG.Tweening.PathType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for DG.Tweening.PathType ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int DGTweeningRotateMode_TypeID = -1; + int DGTweeningRotateMode_EnumRef = -1; + + public void PushDGTweeningRotateMode(RealStatePtr L, DG.Tweening.RotateMode val) + { + if (DGTweeningRotateMode_TypeID == -1) + { + bool is_first; + DGTweeningRotateMode_TypeID = getTypeId(L, typeof(DG.Tweening.RotateMode), out is_first); + + if (DGTweeningRotateMode_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(DG.Tweening.RotateMode)); + DGTweeningRotateMode_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, DGTweeningRotateMode_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, DGTweeningRotateMode_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for DG.Tweening.RotateMode ,value="+val); + } + + LuaAPI.lua_getref(L, DGTweeningRotateMode_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 DG.Tweening.RotateMode val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != DGTweeningRotateMode_TypeID) + { + throw new Exception("invalid userdata for DG.Tweening.RotateMode"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for DG.Tweening.RotateMode"); + } + val = (DG.Tweening.RotateMode)e; + + } + else + { + val = (DG.Tweening.RotateMode)objectCasters.GetCaster(typeof(DG.Tweening.RotateMode))(L, index, null); + } + } + + public void UpdateDGTweeningRotateMode(RealStatePtr L, int index, DG.Tweening.RotateMode val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != DGTweeningRotateMode_TypeID) + { + throw new Exception("invalid userdata for DG.Tweening.RotateMode"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for DG.Tweening.RotateMode ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int DGTweeningScrambleMode_TypeID = -1; + int DGTweeningScrambleMode_EnumRef = -1; + + public void PushDGTweeningScrambleMode(RealStatePtr L, DG.Tweening.ScrambleMode val) + { + if (DGTweeningScrambleMode_TypeID == -1) + { + bool is_first; + DGTweeningScrambleMode_TypeID = getTypeId(L, typeof(DG.Tweening.ScrambleMode), out is_first); + + if (DGTweeningScrambleMode_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(DG.Tweening.ScrambleMode)); + DGTweeningScrambleMode_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, DGTweeningScrambleMode_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, DGTweeningScrambleMode_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for DG.Tweening.ScrambleMode ,value="+val); + } + + LuaAPI.lua_getref(L, DGTweeningScrambleMode_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 DG.Tweening.ScrambleMode val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != DGTweeningScrambleMode_TypeID) + { + throw new Exception("invalid userdata for DG.Tweening.ScrambleMode"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for DG.Tweening.ScrambleMode"); + } + val = (DG.Tweening.ScrambleMode)e; + + } + else + { + val = (DG.Tweening.ScrambleMode)objectCasters.GetCaster(typeof(DG.Tweening.ScrambleMode))(L, index, null); + } + } + + public void UpdateDGTweeningScrambleMode(RealStatePtr L, int index, DG.Tweening.ScrambleMode val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != DGTweeningScrambleMode_TypeID) + { + throw new Exception("invalid userdata for DG.Tweening.ScrambleMode"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for DG.Tweening.ScrambleMode ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int DGTweeningTweenType_TypeID = -1; + int DGTweeningTweenType_EnumRef = -1; + + public void PushDGTweeningTweenType(RealStatePtr L, DG.Tweening.TweenType val) + { + if (DGTweeningTweenType_TypeID == -1) + { + bool is_first; + DGTweeningTweenType_TypeID = getTypeId(L, typeof(DG.Tweening.TweenType), out is_first); + + if (DGTweeningTweenType_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(DG.Tweening.TweenType)); + DGTweeningTweenType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, DGTweeningTweenType_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, DGTweeningTweenType_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for DG.Tweening.TweenType ,value="+val); + } + + LuaAPI.lua_getref(L, DGTweeningTweenType_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 DG.Tweening.TweenType val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != DGTweeningTweenType_TypeID) + { + throw new Exception("invalid userdata for DG.Tweening.TweenType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for DG.Tweening.TweenType"); + } + val = (DG.Tweening.TweenType)e; + + } + else + { + val = (DG.Tweening.TweenType)objectCasters.GetCaster(typeof(DG.Tweening.TweenType))(L, index, null); + } + } + + public void UpdateDGTweeningTweenType(RealStatePtr L, int index, DG.Tweening.TweenType val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != DGTweeningTweenType_TypeID) + { + throw new Exception("invalid userdata for DG.Tweening.TweenType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for DG.Tweening.TweenType ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int DGTweeningUpdateType_TypeID = -1; + int DGTweeningUpdateType_EnumRef = -1; + + public void PushDGTweeningUpdateType(RealStatePtr L, DG.Tweening.UpdateType val) + { + if (DGTweeningUpdateType_TypeID == -1) + { + bool is_first; + DGTweeningUpdateType_TypeID = getTypeId(L, typeof(DG.Tweening.UpdateType), out is_first); + + if (DGTweeningUpdateType_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(DG.Tweening.UpdateType)); + DGTweeningUpdateType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, DGTweeningUpdateType_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, DGTweeningUpdateType_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for DG.Tweening.UpdateType ,value="+val); + } + + LuaAPI.lua_getref(L, DGTweeningUpdateType_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 DG.Tweening.UpdateType val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != DGTweeningUpdateType_TypeID) + { + throw new Exception("invalid userdata for DG.Tweening.UpdateType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for DG.Tweening.UpdateType"); + } + val = (DG.Tweening.UpdateType)e; + + } + else + { + val = (DG.Tweening.UpdateType)objectCasters.GetCaster(typeof(DG.Tweening.UpdateType))(L, index, null); + } + } + + public void UpdateDGTweeningUpdateType(RealStatePtr L, int index, DG.Tweening.UpdateType val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != DGTweeningUpdateType_TypeID) + { + throw new Exception("invalid userdata for DG.Tweening.UpdateType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for DG.Tweening.UpdateType ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int HttpRequestState_TypeID = -1; + int HttpRequestState_EnumRef = -1; + + public void PushHttpRequestState(RealStatePtr L, Http.RequestState val) + { + if (HttpRequestState_TypeID == -1) + { + bool is_first; + HttpRequestState_TypeID = getTypeId(L, typeof(Http.RequestState), out is_first); + + if (HttpRequestState_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(Http.RequestState)); + HttpRequestState_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, HttpRequestState_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, HttpRequestState_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for Http.RequestState ,value="+val); + } + + LuaAPI.lua_getref(L, HttpRequestState_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 Http.RequestState val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != HttpRequestState_TypeID) + { + throw new Exception("invalid userdata for Http.RequestState"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for Http.RequestState"); + } + val = (Http.RequestState)e; + + } + else + { + val = (Http.RequestState)objectCasters.GetCaster(typeof(Http.RequestState))(L, index, null); + } + } + + public void UpdateHttpRequestState(RealStatePtr L, int index, Http.RequestState val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != HttpRequestState_TypeID) + { + throw new Exception("invalid userdata for Http.RequestState"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for Http.RequestState ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int UnityEnginePurchasingProductType_TypeID = -1; + int UnityEnginePurchasingProductType_EnumRef = -1; + + public void PushUnityEnginePurchasingProductType(RealStatePtr L, UnityEngine.Purchasing.ProductType val) + { + if (UnityEnginePurchasingProductType_TypeID == -1) + { + bool is_first; + UnityEnginePurchasingProductType_TypeID = getTypeId(L, typeof(UnityEngine.Purchasing.ProductType), out is_first); + + if (UnityEnginePurchasingProductType_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(UnityEngine.Purchasing.ProductType)); + UnityEnginePurchasingProductType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityEnginePurchasingProductType_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityEnginePurchasingProductType_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for UnityEngine.Purchasing.ProductType ,value="+val); + } + + LuaAPI.lua_getref(L, UnityEnginePurchasingProductType_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 UnityEngine.Purchasing.ProductType val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEnginePurchasingProductType_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Purchasing.ProductType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for UnityEngine.Purchasing.ProductType"); + } + val = (UnityEngine.Purchasing.ProductType)e; + + } + else + { + val = (UnityEngine.Purchasing.ProductType)objectCasters.GetCaster(typeof(UnityEngine.Purchasing.ProductType))(L, index, null); + } + } + + public void UpdateUnityEnginePurchasingProductType(RealStatePtr L, int index, UnityEngine.Purchasing.ProductType val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != UnityEnginePurchasingProductType_TypeID) + { + throw new Exception("invalid userdata for UnityEngine.Purchasing.ProductType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for UnityEngine.Purchasing.ProductType ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int BFBFSliderFillDirection_TypeID = -1; + int BFBFSliderFillDirection_EnumRef = -1; + + public void PushBFBFSliderFillDirection(RealStatePtr L, BF.BFSlider.FillDirection val) + { + if (BFBFSliderFillDirection_TypeID == -1) + { + bool is_first; + BFBFSliderFillDirection_TypeID = getTypeId(L, typeof(BF.BFSlider.FillDirection), out is_first); + + if (BFBFSliderFillDirection_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(BF.BFSlider.FillDirection)); + BFBFSliderFillDirection_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, BFBFSliderFillDirection_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, BFBFSliderFillDirection_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for BF.BFSlider.FillDirection ,value="+val); + } + + LuaAPI.lua_getref(L, BFBFSliderFillDirection_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 BF.BFSlider.FillDirection val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != BFBFSliderFillDirection_TypeID) + { + throw new Exception("invalid userdata for BF.BFSlider.FillDirection"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for BF.BFSlider.FillDirection"); + } + val = (BF.BFSlider.FillDirection)e; + + } + else + { + val = (BF.BFSlider.FillDirection)objectCasters.GetCaster(typeof(BF.BFSlider.FillDirection))(L, index, null); + } + } + + public void UpdateBFBFSliderFillDirection(RealStatePtr L, int index, BF.BFSlider.FillDirection val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != BFBFSliderFillDirection_TypeID) + { + throw new Exception("invalid userdata for BF.BFSlider.FillDirection"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for BF.BFSlider.FillDirection ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int BFScrollRectBaseOldMovementType_TypeID = -1; + int BFScrollRectBaseOldMovementType_EnumRef = -1; + + public void PushBFScrollRectBaseOldMovementType(RealStatePtr L, BF.ScrollRectBaseOld.MovementType val) + { + if (BFScrollRectBaseOldMovementType_TypeID == -1) + { + bool is_first; + BFScrollRectBaseOldMovementType_TypeID = getTypeId(L, typeof(BF.ScrollRectBaseOld.MovementType), out is_first); + + if (BFScrollRectBaseOldMovementType_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(BF.ScrollRectBaseOld.MovementType)); + BFScrollRectBaseOldMovementType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, BFScrollRectBaseOldMovementType_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, BFScrollRectBaseOldMovementType_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for BF.ScrollRectBaseOld.MovementType ,value="+val); + } + + LuaAPI.lua_getref(L, BFScrollRectBaseOldMovementType_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 BF.ScrollRectBaseOld.MovementType val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != BFScrollRectBaseOldMovementType_TypeID) + { + throw new Exception("invalid userdata for BF.ScrollRectBaseOld.MovementType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for BF.ScrollRectBaseOld.MovementType"); + } + val = (BF.ScrollRectBaseOld.MovementType)e; + + } + else + { + val = (BF.ScrollRectBaseOld.MovementType)objectCasters.GetCaster(typeof(BF.ScrollRectBaseOld.MovementType))(L, index, null); + } + } + + public void UpdateBFScrollRectBaseOldMovementType(RealStatePtr L, int index, BF.ScrollRectBaseOld.MovementType val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != BFScrollRectBaseOldMovementType_TypeID) + { + throw new Exception("invalid userdata for BF.ScrollRectBaseOld.MovementType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for BF.ScrollRectBaseOld.MovementType ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int BFScrollRectBaseOldScrollbarVisibility_TypeID = -1; + int BFScrollRectBaseOldScrollbarVisibility_EnumRef = -1; + + public void PushBFScrollRectBaseOldScrollbarVisibility(RealStatePtr L, BF.ScrollRectBaseOld.ScrollbarVisibility val) + { + if (BFScrollRectBaseOldScrollbarVisibility_TypeID == -1) + { + bool is_first; + BFScrollRectBaseOldScrollbarVisibility_TypeID = getTypeId(L, typeof(BF.ScrollRectBaseOld.ScrollbarVisibility), out is_first); + + if (BFScrollRectBaseOldScrollbarVisibility_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(BF.ScrollRectBaseOld.ScrollbarVisibility)); + BFScrollRectBaseOldScrollbarVisibility_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, BFScrollRectBaseOldScrollbarVisibility_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, BFScrollRectBaseOldScrollbarVisibility_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for BF.ScrollRectBaseOld.ScrollbarVisibility ,value="+val); + } + + LuaAPI.lua_getref(L, BFScrollRectBaseOldScrollbarVisibility_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 BF.ScrollRectBaseOld.ScrollbarVisibility val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != BFScrollRectBaseOldScrollbarVisibility_TypeID) + { + throw new Exception("invalid userdata for BF.ScrollRectBaseOld.ScrollbarVisibility"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for BF.ScrollRectBaseOld.ScrollbarVisibility"); + } + val = (BF.ScrollRectBaseOld.ScrollbarVisibility)e; + + } + else + { + val = (BF.ScrollRectBaseOld.ScrollbarVisibility)objectCasters.GetCaster(typeof(BF.ScrollRectBaseOld.ScrollbarVisibility))(L, index, null); + } + } + + public void UpdateBFScrollRectBaseOldScrollbarVisibility(RealStatePtr L, int index, BF.ScrollRectBaseOld.ScrollbarVisibility val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != BFScrollRectBaseOldScrollbarVisibility_TypeID) + { + throw new Exception("invalid userdata for BF.ScrollRectBaseOld.ScrollbarVisibility"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for BF.ScrollRectBaseOld.ScrollbarVisibility ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int BFNetServiceType_TypeID = -1; + int BFNetServiceType_EnumRef = -1; + + public void PushBFNetServiceType(RealStatePtr L, BF.NetServiceType val) + { + if (BFNetServiceType_TypeID == -1) + { + bool is_first; + BFNetServiceType_TypeID = getTypeId(L, typeof(BF.NetServiceType), out is_first); + + if (BFNetServiceType_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(BF.NetServiceType)); + BFNetServiceType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, BFNetServiceType_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, BFNetServiceType_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for BF.NetServiceType ,value="+val); + } + + LuaAPI.lua_getref(L, BFNetServiceType_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 BF.NetServiceType val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != BFNetServiceType_TypeID) + { + throw new Exception("invalid userdata for BF.NetServiceType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for BF.NetServiceType"); + } + val = (BF.NetServiceType)e; + + } + else + { + val = (BF.NetServiceType)objectCasters.GetCaster(typeof(BF.NetServiceType))(L, index, null); + } + } + + public void UpdateBFNetServiceType(RealStatePtr L, int index, BF.NetServiceType val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != BFNetServiceType_TypeID) + { + throw new Exception("invalid userdata for BF.NetServiceType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for BF.NetServiceType ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int BFNetIncomingMessageType_TypeID = -1; + int BFNetIncomingMessageType_EnumRef = -1; + + public void PushBFNetIncomingMessageType(RealStatePtr L, BF.NetIncomingMessageType val) + { + if (BFNetIncomingMessageType_TypeID == -1) + { + bool is_first; + BFNetIncomingMessageType_TypeID = getTypeId(L, typeof(BF.NetIncomingMessageType), out is_first); + + if (BFNetIncomingMessageType_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(BF.NetIncomingMessageType)); + BFNetIncomingMessageType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, BFNetIncomingMessageType_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, BFNetIncomingMessageType_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for BF.NetIncomingMessageType ,value="+val); + } + + LuaAPI.lua_getref(L, BFNetIncomingMessageType_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 BF.NetIncomingMessageType val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != BFNetIncomingMessageType_TypeID) + { + throw new Exception("invalid userdata for BF.NetIncomingMessageType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for BF.NetIncomingMessageType"); + } + val = (BF.NetIncomingMessageType)e; + + } + else + { + val = (BF.NetIncomingMessageType)objectCasters.GetCaster(typeof(BF.NetIncomingMessageType))(L, index, null); + } + } + + public void UpdateBFNetIncomingMessageType(RealStatePtr L, int index, BF.NetIncomingMessageType val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != BFNetIncomingMessageType_TypeID) + { + throw new Exception("invalid userdata for BF.NetIncomingMessageType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for BF.NetIncomingMessageType ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int BFTouchEventType_TypeID = -1; + int BFTouchEventType_EnumRef = -1; + + public void PushBFTouchEventType(RealStatePtr L, BF.TouchEventType val) + { + if (BFTouchEventType_TypeID == -1) + { + bool is_first; + BFTouchEventType_TypeID = getTypeId(L, typeof(BF.TouchEventType), out is_first); + + if (BFTouchEventType_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(BF.TouchEventType)); + BFTouchEventType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, BFTouchEventType_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, BFTouchEventType_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for BF.TouchEventType ,value="+val); + } + + LuaAPI.lua_getref(L, BFTouchEventType_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 BF.TouchEventType val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != BFTouchEventType_TypeID) + { + throw new Exception("invalid userdata for BF.TouchEventType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for BF.TouchEventType"); + } + val = (BF.TouchEventType)e; + + } + else + { + val = (BF.TouchEventType)objectCasters.GetCaster(typeof(BF.TouchEventType))(L, index, null); + } + } + + public void UpdateBFTouchEventType(RealStatePtr L, int index, BF.TouchEventType val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != BFTouchEventType_TypeID) + { + throw new Exception("invalid userdata for BF.TouchEventType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for BF.TouchEventType ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + int BFSelectEventType_TypeID = -1; + int BFSelectEventType_EnumRef = -1; + + public void PushBFSelectEventType(RealStatePtr L, BF.SelectEventType val) + { + if (BFSelectEventType_TypeID == -1) + { + bool is_first; + BFSelectEventType_TypeID = getTypeId(L, typeof(BF.SelectEventType), out is_first); + + if (BFSelectEventType_EnumRef == -1) + { + Utils.LoadCSTable(L, typeof(BF.SelectEventType)); + BFSelectEventType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX); + } + + } + + if (LuaAPI.xlua_tryget_cachedud(L, (int)val, BFSelectEventType_EnumRef) == 1) + { + return; + } + + IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, BFSelectEventType_TypeID); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail fail for BF.SelectEventType ,value="+val); + } + + LuaAPI.lua_getref(L, BFSelectEventType_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 BF.SelectEventType val) + { + LuaTypes type = LuaAPI.lua_type(L, index); + if (type == LuaTypes.LUA_TUSERDATA ) + { + if (LuaAPI.xlua_gettypeid(L, index) != BFSelectEventType_TypeID) + { + throw new Exception("invalid userdata for BF.SelectEventType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + int e; + if (!CopyByValue.UnPack(buff, 0, out e)) + { + throw new Exception("unpack fail for BF.SelectEventType"); + } + val = (BF.SelectEventType)e; + + } + else + { + val = (BF.SelectEventType)objectCasters.GetCaster(typeof(BF.SelectEventType))(L, index, null); + } + } + + public void UpdateBFSelectEventType(RealStatePtr L, int index, BF.SelectEventType val) + { + + if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA) + { + if (LuaAPI.xlua_gettypeid(L, index) != BFSelectEventType_TypeID) + { + throw new Exception("invalid userdata for BF.SelectEventType"); + } + + IntPtr buff = LuaAPI.lua_touserdata(L, index); + if (!CopyByValue.Pack(buff, 0, (int)val)) + { + throw new Exception("pack fail for BF.SelectEventType ,value="+val); + } + } + + else + { + throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index)); + } + } + + + // table cast optimze + + + } + + public partial class StaticLuaCallbacks + { + internal static bool __tryArrayGet(Type type, RealStatePtr L, ObjectTranslator translator, object obj, int index) + { + + if (type == typeof(UnityEngine.Vector2[])) + { + UnityEngine.Vector2[] array = obj as UnityEngine.Vector2[]; + translator.PushUnityEngineVector2(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.Vector3[])) + { + UnityEngine.Vector3[] array = obj as UnityEngine.Vector3[]; + translator.PushUnityEngineVector3(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.Vector4[])) + { + UnityEngine.Vector4[] array = obj as UnityEngine.Vector4[]; + translator.PushUnityEngineVector4(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.Color[])) + { + UnityEngine.Color[] array = obj as UnityEngine.Color[]; + translator.PushUnityEngineColor(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.Quaternion[])) + { + UnityEngine.Quaternion[] array = obj as UnityEngine.Quaternion[]; + translator.PushUnityEngineQuaternion(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.Ray[])) + { + UnityEngine.Ray[] array = obj as UnityEngine.Ray[]; + translator.PushUnityEngineRay(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.Bounds[])) + { + UnityEngine.Bounds[] array = obj as UnityEngine.Bounds[]; + translator.PushUnityEngineBounds(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.Ray2D[])) + { + UnityEngine.Ray2D[] array = obj as UnityEngine.Ray2D[]; + translator.PushUnityEngineRay2D(L, array[index]); + return true; + } + else if (type == typeof(AdFormat[])) + { + AdFormat[] array = obj as AdFormat[]; + translator.PushAdFormat(L, array[index]); + return true; + } + else if (type == typeof(IronSourceBannerPosition[])) + { + IronSourceBannerPosition[] array = obj as IronSourceBannerPosition[]; + translator.PushIronSourceBannerPosition(L, array[index]); + return true; + } + else if (type == typeof(UIImageSheetAnimation.AnimationType[])) + { + UIImageSheetAnimation.AnimationType[] array = obj as UIImageSheetAnimation.AnimationType[]; + translator.PushUIImageSheetAnimationAnimationType(L, array[index]); + return true; + } + else if (type == typeof(UIImageSheetAnimation.TimeType[])) + { + UIImageSheetAnimation.TimeType[] array = obj as UIImageSheetAnimation.TimeType[]; + translator.PushUIImageSheetAnimationTimeType(L, array[index]); + return true; + } + else if (type == typeof(UIImageSheetAnimation.StartFrameType[])) + { + UIImageSheetAnimation.StartFrameType[] array = obj as UIImageSheetAnimation.StartFrameType[]; + translator.PushUIImageSheetAnimationStartFrameType(L, array[index]); + return true; + } + else if (type == typeof(System.Reflection.BindingFlags[])) + { + System.Reflection.BindingFlags[] array = obj as System.Reflection.BindingFlags[]; + translator.PushSystemReflectionBindingFlags(L, array[index]); + return true; + } + else if (type == typeof(System.DayOfWeek[])) + { + System.DayOfWeek[] array = obj as System.DayOfWeek[]; + translator.PushSystemDayOfWeek(L, array[index]); + return true; + } + else if (type == typeof(System.Net.NetworkInformation.IPStatus[])) + { + System.Net.NetworkInformation.IPStatus[] array = obj as System.Net.NetworkInformation.IPStatus[]; + translator.PushSystemNetNetworkInformationIPStatus(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.Camera.GateFitMode[])) + { + UnityEngine.Camera.GateFitMode[] array = obj as UnityEngine.Camera.GateFitMode[]; + translator.PushUnityEngineCameraGateFitMode(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.Camera.StereoscopicEye[])) + { + UnityEngine.Camera.StereoscopicEye[] array = obj as UnityEngine.Camera.StereoscopicEye[]; + translator.PushUnityEngineCameraStereoscopicEye(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.Camera.MonoOrStereoscopicEye[])) + { + UnityEngine.Camera.MonoOrStereoscopicEye[] array = obj as UnityEngine.Camera.MonoOrStereoscopicEye[]; + translator.PushUnityEngineCameraMonoOrStereoscopicEye(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.Camera.FieldOfViewAxis[])) + { + UnityEngine.Camera.FieldOfViewAxis[] array = obj as UnityEngine.Camera.FieldOfViewAxis[]; + translator.PushUnityEngineCameraFieldOfViewAxis(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.Camera.RenderRequestMode[])) + { + UnityEngine.Camera.RenderRequestMode[] array = obj as UnityEngine.Camera.RenderRequestMode[]; + translator.PushUnityEngineCameraRenderRequestMode(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.Camera.RenderRequestOutputSpace[])) + { + UnityEngine.Camera.RenderRequestOutputSpace[] array = obj as UnityEngine.Camera.RenderRequestOutputSpace[]; + translator.PushUnityEngineCameraRenderRequestOutputSpace(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.Camera.SceneViewFilterMode[])) + { + UnityEngine.Camera.SceneViewFilterMode[] array = obj as UnityEngine.Camera.SceneViewFilterMode[]; + translator.PushUnityEngineCameraSceneViewFilterMode(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.Rendering.LightShadowResolution[])) + { + UnityEngine.Rendering.LightShadowResolution[] array = obj as UnityEngine.Rendering.LightShadowResolution[]; + translator.PushUnityEngineRenderingLightShadowResolution(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.RenderTextureFormat[])) + { + UnityEngine.RenderTextureFormat[] array = obj as UnityEngine.RenderTextureFormat[]; + translator.PushUnityEngineRenderTextureFormat(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.RenderTextureReadWrite[])) + { + UnityEngine.RenderTextureReadWrite[] array = obj as UnityEngine.RenderTextureReadWrite[]; + translator.PushUnityEngineRenderTextureReadWrite(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.RigidbodyConstraints[])) + { + UnityEngine.RigidbodyConstraints[] array = obj as UnityEngine.RigidbodyConstraints[]; + translator.PushUnityEngineRigidbodyConstraints(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.TransparencySortMode[])) + { + UnityEngine.TransparencySortMode[] array = obj as UnityEngine.TransparencySortMode[]; + translator.PushUnityEngineTransparencySortMode(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.RectTransform.Axis[])) + { + UnityEngine.RectTransform.Axis[] array = obj as UnityEngine.RectTransform.Axis[]; + translator.PushUnityEngineRectTransformAxis(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.RectTransform.Edge[])) + { + UnityEngine.RectTransform.Edge[] array = obj as UnityEngine.RectTransform.Edge[]; + translator.PushUnityEngineRectTransformEdge(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.AnimatorCullingMode[])) + { + UnityEngine.AnimatorCullingMode[] array = obj as UnityEngine.AnimatorCullingMode[]; + translator.PushUnityEngineAnimatorCullingMode(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.SystemLanguage[])) + { + UnityEngine.SystemLanguage[] array = obj as UnityEngine.SystemLanguage[]; + translator.PushUnityEngineSystemLanguage(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.Rendering.ShadowCastingMode[])) + { + UnityEngine.Rendering.ShadowCastingMode[] array = obj as UnityEngine.Rendering.ShadowCastingMode[]; + translator.PushUnityEngineRenderingShadowCastingMode(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.Texture2D.EXRFlags[])) + { + UnityEngine.Texture2D.EXRFlags[] array = obj as UnityEngine.Texture2D.EXRFlags[]; + translator.PushUnityEngineTexture2DEXRFlags(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.KeyCode[])) + { + UnityEngine.KeyCode[] array = obj as UnityEngine.KeyCode[]; + translator.PushUnityEngineKeyCode(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.NetworkReachability[])) + { + UnityEngine.NetworkReachability[] array = obj as UnityEngine.NetworkReachability[]; + translator.PushUnityEngineNetworkReachability(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.RuntimePlatform[])) + { + UnityEngine.RuntimePlatform[] array = obj as UnityEngine.RuntimePlatform[]; + translator.PushUnityEngineRuntimePlatform(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.Rendering.CompareFunction[])) + { + UnityEngine.Rendering.CompareFunction[] array = obj as UnityEngine.Rendering.CompareFunction[]; + translator.PushUnityEngineRenderingCompareFunction(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.TextAnchor[])) + { + UnityEngine.TextAnchor[] array = obj as UnityEngine.TextAnchor[]; + translator.PushUnityEngineTextAnchor(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.BatteryStatus[])) + { + UnityEngine.BatteryStatus[] array = obj as UnityEngine.BatteryStatus[]; + translator.PushUnityEngineBatteryStatus(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.UI.GraphicRaycaster.BlockingObjects[])) + { + UnityEngine.UI.GraphicRaycaster.BlockingObjects[] array = obj as UnityEngine.UI.GraphicRaycaster.BlockingObjects[]; + translator.PushUnityEngineUIGraphicRaycasterBlockingObjects(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.UI.Image.Type[])) + { + UnityEngine.UI.Image.Type[] array = obj as UnityEngine.UI.Image.Type[]; + translator.PushUnityEngineUIImageType(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.UI.Image.FillMethod[])) + { + UnityEngine.UI.Image.FillMethod[] array = obj as UnityEngine.UI.Image.FillMethod[]; + translator.PushUnityEngineUIImageFillMethod(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.UI.Image.OriginHorizontal[])) + { + UnityEngine.UI.Image.OriginHorizontal[] array = obj as UnityEngine.UI.Image.OriginHorizontal[]; + translator.PushUnityEngineUIImageOriginHorizontal(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.UI.Image.OriginVertical[])) + { + UnityEngine.UI.Image.OriginVertical[] array = obj as UnityEngine.UI.Image.OriginVertical[]; + translator.PushUnityEngineUIImageOriginVertical(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.UI.Image.Origin90[])) + { + UnityEngine.UI.Image.Origin90[] array = obj as UnityEngine.UI.Image.Origin90[]; + translator.PushUnityEngineUIImageOrigin90(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.UI.Image.Origin180[])) + { + UnityEngine.UI.Image.Origin180[] array = obj as UnityEngine.UI.Image.Origin180[]; + translator.PushUnityEngineUIImageOrigin180(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.UI.Image.Origin360[])) + { + UnityEngine.UI.Image.Origin360[] array = obj as UnityEngine.UI.Image.Origin360[]; + translator.PushUnityEngineUIImageOrigin360(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.UI.InputField.ContentType[])) + { + UnityEngine.UI.InputField.ContentType[] array = obj as UnityEngine.UI.InputField.ContentType[]; + translator.PushUnityEngineUIInputFieldContentType(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.UI.InputField.InputType[])) + { + UnityEngine.UI.InputField.InputType[] array = obj as UnityEngine.UI.InputField.InputType[]; + translator.PushUnityEngineUIInputFieldInputType(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.UI.InputField.CharacterValidation[])) + { + UnityEngine.UI.InputField.CharacterValidation[] array = obj as UnityEngine.UI.InputField.CharacterValidation[]; + translator.PushUnityEngineUIInputFieldCharacterValidation(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.UI.InputField.LineType[])) + { + UnityEngine.UI.InputField.LineType[] array = obj as UnityEngine.UI.InputField.LineType[]; + translator.PushUnityEngineUIInputFieldLineType(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.UI.ScrollRect.MovementType[])) + { + UnityEngine.UI.ScrollRect.MovementType[] array = obj as UnityEngine.UI.ScrollRect.MovementType[]; + translator.PushUnityEngineUIScrollRectMovementType(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.UI.ScrollRect.ScrollbarVisibility[])) + { + UnityEngine.UI.ScrollRect.ScrollbarVisibility[] array = obj as UnityEngine.UI.ScrollRect.ScrollbarVisibility[]; + translator.PushUnityEngineUIScrollRectScrollbarVisibility(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.UI.Slider.Direction[])) + { + UnityEngine.UI.Slider.Direction[] array = obj as UnityEngine.UI.Slider.Direction[]; + translator.PushUnityEngineUISliderDirection(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.UI.Toggle.ToggleTransition[])) + { + UnityEngine.UI.Toggle.ToggleTransition[] array = obj as UnityEngine.UI.Toggle.ToggleTransition[]; + translator.PushUnityEngineUIToggleToggleTransition(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.UI.GridLayoutGroup.Corner[])) + { + UnityEngine.UI.GridLayoutGroup.Corner[] array = obj as UnityEngine.UI.GridLayoutGroup.Corner[]; + translator.PushUnityEngineUIGridLayoutGroupCorner(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.UI.GridLayoutGroup.Axis[])) + { + UnityEngine.UI.GridLayoutGroup.Axis[] array = obj as UnityEngine.UI.GridLayoutGroup.Axis[]; + translator.PushUnityEngineUIGridLayoutGroupAxis(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.UI.GridLayoutGroup.Constraint[])) + { + UnityEngine.UI.GridLayoutGroup.Constraint[] array = obj as UnityEngine.UI.GridLayoutGroup.Constraint[]; + translator.PushUnityEngineUIGridLayoutGroupConstraint(L, array[index]); + return true; + } + else if (type == typeof(Spine.Unity.BoneFollower.AxisOrientation[])) + { + Spine.Unity.BoneFollower.AxisOrientation[] array = obj as Spine.Unity.BoneFollower.AxisOrientation[]; + translator.PushSpineUnityBoneFollowerAxisOrientation(L, array[index]); + return true; + } + else if (type == typeof(Spine.Unity.SkeletonGraphic.LayoutMode[])) + { + Spine.Unity.SkeletonGraphic.LayoutMode[] array = obj as Spine.Unity.SkeletonGraphic.LayoutMode[]; + translator.PushSpineUnitySkeletonGraphicLayoutMode(L, array[index]); + return true; + } + else if (type == typeof(TMPro.TextAlignmentOptions[])) + { + TMPro.TextAlignmentOptions[] array = obj as TMPro.TextAlignmentOptions[]; + translator.PushTMProTextAlignmentOptions(L, array[index]); + return true; + } + else if (type == typeof(TMPro.TMP_InputField.ContentType[])) + { + TMPro.TMP_InputField.ContentType[] array = obj as TMPro.TMP_InputField.ContentType[]; + translator.PushTMProTMP_InputFieldContentType(L, array[index]); + return true; + } + else if (type == typeof(TMPro.TMP_InputField.InputType[])) + { + TMPro.TMP_InputField.InputType[] array = obj as TMPro.TMP_InputField.InputType[]; + translator.PushTMProTMP_InputFieldInputType(L, array[index]); + return true; + } + else if (type == typeof(TMPro.TMP_InputField.CharacterValidation[])) + { + TMPro.TMP_InputField.CharacterValidation[] array = obj as TMPro.TMP_InputField.CharacterValidation[]; + translator.PushTMProTMP_InputFieldCharacterValidation(L, array[index]); + return true; + } + else if (type == typeof(TMPro.TMP_InputField.LineType[])) + { + TMPro.TMP_InputField.LineType[] array = obj as TMPro.TMP_InputField.LineType[]; + translator.PushTMProTMP_InputFieldLineType(L, array[index]); + return true; + } + else if (type == typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone[])) + { + ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone[] array = obj as ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone[]; + translator.PushThinkingAnalyticsThinkingAnalyticsAPITATimeZone(L, array[index]); + return true; + } + else if (type == typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode[])) + { + ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode[] array = obj as ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode[]; + translator.PushThinkingAnalyticsThinkingAnalyticsAPITAMode(L, array[index]); + return true; + } + else if (type == typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType[])) + { + ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType[] array = obj as ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType[]; + translator.PushThinkingAnalyticsThinkingAnalyticsAPINetworkType(L, array[index]); + return true; + } + else if (type == typeof(DG.Tweening.AutoPlay[])) + { + DG.Tweening.AutoPlay[] array = obj as DG.Tweening.AutoPlay[]; + translator.PushDGTweeningAutoPlay(L, array[index]); + return true; + } + else if (type == typeof(DG.Tweening.AxisConstraint[])) + { + DG.Tweening.AxisConstraint[] array = obj as DG.Tweening.AxisConstraint[]; + translator.PushDGTweeningAxisConstraint(L, array[index]); + return true; + } + else if (type == typeof(DG.Tweening.Ease[])) + { + DG.Tweening.Ease[] array = obj as DG.Tweening.Ease[]; + translator.PushDGTweeningEase(L, array[index]); + return true; + } + else if (type == typeof(DG.Tweening.LogBehaviour[])) + { + DG.Tweening.LogBehaviour[] array = obj as DG.Tweening.LogBehaviour[]; + translator.PushDGTweeningLogBehaviour(L, array[index]); + return true; + } + else if (type == typeof(DG.Tweening.LoopType[])) + { + DG.Tweening.LoopType[] array = obj as DG.Tweening.LoopType[]; + translator.PushDGTweeningLoopType(L, array[index]); + return true; + } + else if (type == typeof(DG.Tweening.PathMode[])) + { + DG.Tweening.PathMode[] array = obj as DG.Tweening.PathMode[]; + translator.PushDGTweeningPathMode(L, array[index]); + return true; + } + else if (type == typeof(DG.Tweening.PathType[])) + { + DG.Tweening.PathType[] array = obj as DG.Tweening.PathType[]; + translator.PushDGTweeningPathType(L, array[index]); + return true; + } + else if (type == typeof(DG.Tweening.RotateMode[])) + { + DG.Tweening.RotateMode[] array = obj as DG.Tweening.RotateMode[]; + translator.PushDGTweeningRotateMode(L, array[index]); + return true; + } + else if (type == typeof(DG.Tweening.ScrambleMode[])) + { + DG.Tweening.ScrambleMode[] array = obj as DG.Tweening.ScrambleMode[]; + translator.PushDGTweeningScrambleMode(L, array[index]); + return true; + } + else if (type == typeof(DG.Tweening.TweenType[])) + { + DG.Tweening.TweenType[] array = obj as DG.Tweening.TweenType[]; + translator.PushDGTweeningTweenType(L, array[index]); + return true; + } + else if (type == typeof(DG.Tweening.UpdateType[])) + { + DG.Tweening.UpdateType[] array = obj as DG.Tweening.UpdateType[]; + translator.PushDGTweeningUpdateType(L, array[index]); + return true; + } + else if (type == typeof(Http.RequestState[])) + { + Http.RequestState[] array = obj as Http.RequestState[]; + translator.PushHttpRequestState(L, array[index]); + return true; + } + else if (type == typeof(UnityEngine.Purchasing.ProductType[])) + { + UnityEngine.Purchasing.ProductType[] array = obj as UnityEngine.Purchasing.ProductType[]; + translator.PushUnityEnginePurchasingProductType(L, array[index]); + return true; + } + else if (type == typeof(BF.BFSlider.FillDirection[])) + { + BF.BFSlider.FillDirection[] array = obj as BF.BFSlider.FillDirection[]; + translator.PushBFBFSliderFillDirection(L, array[index]); + return true; + } + else if (type == typeof(BF.ScrollRectBaseOld.MovementType[])) + { + BF.ScrollRectBaseOld.MovementType[] array = obj as BF.ScrollRectBaseOld.MovementType[]; + translator.PushBFScrollRectBaseOldMovementType(L, array[index]); + return true; + } + else if (type == typeof(BF.ScrollRectBaseOld.ScrollbarVisibility[])) + { + BF.ScrollRectBaseOld.ScrollbarVisibility[] array = obj as BF.ScrollRectBaseOld.ScrollbarVisibility[]; + translator.PushBFScrollRectBaseOldScrollbarVisibility(L, array[index]); + return true; + } + else if (type == typeof(BF.NetServiceType[])) + { + BF.NetServiceType[] array = obj as BF.NetServiceType[]; + translator.PushBFNetServiceType(L, array[index]); + return true; + } + else if (type == typeof(BF.NetIncomingMessageType[])) + { + BF.NetIncomingMessageType[] array = obj as BF.NetIncomingMessageType[]; + translator.PushBFNetIncomingMessageType(L, array[index]); + return true; + } + else if (type == typeof(BF.TouchEventType[])) + { + BF.TouchEventType[] array = obj as BF.TouchEventType[]; + translator.PushBFTouchEventType(L, array[index]); + return true; + } + else if (type == typeof(BF.SelectEventType[])) + { + BF.SelectEventType[] array = obj as BF.SelectEventType[]; + translator.PushBFSelectEventType(L, array[index]); + return true; + } + return false; + } + + internal static bool __tryArraySet(Type type, RealStatePtr L, ObjectTranslator translator, object obj, int array_idx, int obj_idx) + { + + if (type == typeof(UnityEngine.Vector2[])) + { + UnityEngine.Vector2[] array = obj as UnityEngine.Vector2[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.Vector3[])) + { + UnityEngine.Vector3[] array = obj as UnityEngine.Vector3[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.Vector4[])) + { + UnityEngine.Vector4[] array = obj as UnityEngine.Vector4[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.Color[])) + { + UnityEngine.Color[] array = obj as UnityEngine.Color[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.Quaternion[])) + { + UnityEngine.Quaternion[] array = obj as UnityEngine.Quaternion[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.Ray[])) + { + UnityEngine.Ray[] array = obj as UnityEngine.Ray[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.Bounds[])) + { + UnityEngine.Bounds[] array = obj as UnityEngine.Bounds[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.Ray2D[])) + { + UnityEngine.Ray2D[] array = obj as UnityEngine.Ray2D[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(AdFormat[])) + { + AdFormat[] array = obj as AdFormat[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(IronSourceBannerPosition[])) + { + IronSourceBannerPosition[] array = obj as IronSourceBannerPosition[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UIImageSheetAnimation.AnimationType[])) + { + UIImageSheetAnimation.AnimationType[] array = obj as UIImageSheetAnimation.AnimationType[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UIImageSheetAnimation.TimeType[])) + { + UIImageSheetAnimation.TimeType[] array = obj as UIImageSheetAnimation.TimeType[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UIImageSheetAnimation.StartFrameType[])) + { + UIImageSheetAnimation.StartFrameType[] array = obj as UIImageSheetAnimation.StartFrameType[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(System.Reflection.BindingFlags[])) + { + System.Reflection.BindingFlags[] array = obj as System.Reflection.BindingFlags[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(System.DayOfWeek[])) + { + System.DayOfWeek[] array = obj as System.DayOfWeek[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(System.Net.NetworkInformation.IPStatus[])) + { + System.Net.NetworkInformation.IPStatus[] array = obj as System.Net.NetworkInformation.IPStatus[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.Camera.GateFitMode[])) + { + UnityEngine.Camera.GateFitMode[] array = obj as UnityEngine.Camera.GateFitMode[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.Camera.StereoscopicEye[])) + { + UnityEngine.Camera.StereoscopicEye[] array = obj as UnityEngine.Camera.StereoscopicEye[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.Camera.MonoOrStereoscopicEye[])) + { + UnityEngine.Camera.MonoOrStereoscopicEye[] array = obj as UnityEngine.Camera.MonoOrStereoscopicEye[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.Camera.FieldOfViewAxis[])) + { + UnityEngine.Camera.FieldOfViewAxis[] array = obj as UnityEngine.Camera.FieldOfViewAxis[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.Camera.RenderRequestMode[])) + { + UnityEngine.Camera.RenderRequestMode[] array = obj as UnityEngine.Camera.RenderRequestMode[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.Camera.RenderRequestOutputSpace[])) + { + UnityEngine.Camera.RenderRequestOutputSpace[] array = obj as UnityEngine.Camera.RenderRequestOutputSpace[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.Camera.SceneViewFilterMode[])) + { + UnityEngine.Camera.SceneViewFilterMode[] array = obj as UnityEngine.Camera.SceneViewFilterMode[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.Rendering.LightShadowResolution[])) + { + UnityEngine.Rendering.LightShadowResolution[] array = obj as UnityEngine.Rendering.LightShadowResolution[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.RenderTextureFormat[])) + { + UnityEngine.RenderTextureFormat[] array = obj as UnityEngine.RenderTextureFormat[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.RenderTextureReadWrite[])) + { + UnityEngine.RenderTextureReadWrite[] array = obj as UnityEngine.RenderTextureReadWrite[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.RigidbodyConstraints[])) + { + UnityEngine.RigidbodyConstraints[] array = obj as UnityEngine.RigidbodyConstraints[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.TransparencySortMode[])) + { + UnityEngine.TransparencySortMode[] array = obj as UnityEngine.TransparencySortMode[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.RectTransform.Axis[])) + { + UnityEngine.RectTransform.Axis[] array = obj as UnityEngine.RectTransform.Axis[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.RectTransform.Edge[])) + { + UnityEngine.RectTransform.Edge[] array = obj as UnityEngine.RectTransform.Edge[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.AnimatorCullingMode[])) + { + UnityEngine.AnimatorCullingMode[] array = obj as UnityEngine.AnimatorCullingMode[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.SystemLanguage[])) + { + UnityEngine.SystemLanguage[] array = obj as UnityEngine.SystemLanguage[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.Rendering.ShadowCastingMode[])) + { + UnityEngine.Rendering.ShadowCastingMode[] array = obj as UnityEngine.Rendering.ShadowCastingMode[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.Texture2D.EXRFlags[])) + { + UnityEngine.Texture2D.EXRFlags[] array = obj as UnityEngine.Texture2D.EXRFlags[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.KeyCode[])) + { + UnityEngine.KeyCode[] array = obj as UnityEngine.KeyCode[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.NetworkReachability[])) + { + UnityEngine.NetworkReachability[] array = obj as UnityEngine.NetworkReachability[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.RuntimePlatform[])) + { + UnityEngine.RuntimePlatform[] array = obj as UnityEngine.RuntimePlatform[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.Rendering.CompareFunction[])) + { + UnityEngine.Rendering.CompareFunction[] array = obj as UnityEngine.Rendering.CompareFunction[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.TextAnchor[])) + { + UnityEngine.TextAnchor[] array = obj as UnityEngine.TextAnchor[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.BatteryStatus[])) + { + UnityEngine.BatteryStatus[] array = obj as UnityEngine.BatteryStatus[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.UI.GraphicRaycaster.BlockingObjects[])) + { + UnityEngine.UI.GraphicRaycaster.BlockingObjects[] array = obj as UnityEngine.UI.GraphicRaycaster.BlockingObjects[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.UI.Image.Type[])) + { + UnityEngine.UI.Image.Type[] array = obj as UnityEngine.UI.Image.Type[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.UI.Image.FillMethod[])) + { + UnityEngine.UI.Image.FillMethod[] array = obj as UnityEngine.UI.Image.FillMethod[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.UI.Image.OriginHorizontal[])) + { + UnityEngine.UI.Image.OriginHorizontal[] array = obj as UnityEngine.UI.Image.OriginHorizontal[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.UI.Image.OriginVertical[])) + { + UnityEngine.UI.Image.OriginVertical[] array = obj as UnityEngine.UI.Image.OriginVertical[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.UI.Image.Origin90[])) + { + UnityEngine.UI.Image.Origin90[] array = obj as UnityEngine.UI.Image.Origin90[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.UI.Image.Origin180[])) + { + UnityEngine.UI.Image.Origin180[] array = obj as UnityEngine.UI.Image.Origin180[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.UI.Image.Origin360[])) + { + UnityEngine.UI.Image.Origin360[] array = obj as UnityEngine.UI.Image.Origin360[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.UI.InputField.ContentType[])) + { + UnityEngine.UI.InputField.ContentType[] array = obj as UnityEngine.UI.InputField.ContentType[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.UI.InputField.InputType[])) + { + UnityEngine.UI.InputField.InputType[] array = obj as UnityEngine.UI.InputField.InputType[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.UI.InputField.CharacterValidation[])) + { + UnityEngine.UI.InputField.CharacterValidation[] array = obj as UnityEngine.UI.InputField.CharacterValidation[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.UI.InputField.LineType[])) + { + UnityEngine.UI.InputField.LineType[] array = obj as UnityEngine.UI.InputField.LineType[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.UI.ScrollRect.MovementType[])) + { + UnityEngine.UI.ScrollRect.MovementType[] array = obj as UnityEngine.UI.ScrollRect.MovementType[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.UI.ScrollRect.ScrollbarVisibility[])) + { + UnityEngine.UI.ScrollRect.ScrollbarVisibility[] array = obj as UnityEngine.UI.ScrollRect.ScrollbarVisibility[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.UI.Slider.Direction[])) + { + UnityEngine.UI.Slider.Direction[] array = obj as UnityEngine.UI.Slider.Direction[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.UI.Toggle.ToggleTransition[])) + { + UnityEngine.UI.Toggle.ToggleTransition[] array = obj as UnityEngine.UI.Toggle.ToggleTransition[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.UI.GridLayoutGroup.Corner[])) + { + UnityEngine.UI.GridLayoutGroup.Corner[] array = obj as UnityEngine.UI.GridLayoutGroup.Corner[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.UI.GridLayoutGroup.Axis[])) + { + UnityEngine.UI.GridLayoutGroup.Axis[] array = obj as UnityEngine.UI.GridLayoutGroup.Axis[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.UI.GridLayoutGroup.Constraint[])) + { + UnityEngine.UI.GridLayoutGroup.Constraint[] array = obj as UnityEngine.UI.GridLayoutGroup.Constraint[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(Spine.Unity.BoneFollower.AxisOrientation[])) + { + Spine.Unity.BoneFollower.AxisOrientation[] array = obj as Spine.Unity.BoneFollower.AxisOrientation[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(Spine.Unity.SkeletonGraphic.LayoutMode[])) + { + Spine.Unity.SkeletonGraphic.LayoutMode[] array = obj as Spine.Unity.SkeletonGraphic.LayoutMode[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(TMPro.TextAlignmentOptions[])) + { + TMPro.TextAlignmentOptions[] array = obj as TMPro.TextAlignmentOptions[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(TMPro.TMP_InputField.ContentType[])) + { + TMPro.TMP_InputField.ContentType[] array = obj as TMPro.TMP_InputField.ContentType[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(TMPro.TMP_InputField.InputType[])) + { + TMPro.TMP_InputField.InputType[] array = obj as TMPro.TMP_InputField.InputType[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(TMPro.TMP_InputField.CharacterValidation[])) + { + TMPro.TMP_InputField.CharacterValidation[] array = obj as TMPro.TMP_InputField.CharacterValidation[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(TMPro.TMP_InputField.LineType[])) + { + TMPro.TMP_InputField.LineType[] array = obj as TMPro.TMP_InputField.LineType[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone[])) + { + ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone[] array = obj as ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode[])) + { + ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode[] array = obj as ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType[])) + { + ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType[] array = obj as ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(DG.Tweening.AutoPlay[])) + { + DG.Tweening.AutoPlay[] array = obj as DG.Tweening.AutoPlay[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(DG.Tweening.AxisConstraint[])) + { + DG.Tweening.AxisConstraint[] array = obj as DG.Tweening.AxisConstraint[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(DG.Tweening.Ease[])) + { + DG.Tweening.Ease[] array = obj as DG.Tweening.Ease[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(DG.Tweening.LogBehaviour[])) + { + DG.Tweening.LogBehaviour[] array = obj as DG.Tweening.LogBehaviour[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(DG.Tweening.LoopType[])) + { + DG.Tweening.LoopType[] array = obj as DG.Tweening.LoopType[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(DG.Tweening.PathMode[])) + { + DG.Tweening.PathMode[] array = obj as DG.Tweening.PathMode[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(DG.Tweening.PathType[])) + { + DG.Tweening.PathType[] array = obj as DG.Tweening.PathType[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(DG.Tweening.RotateMode[])) + { + DG.Tweening.RotateMode[] array = obj as DG.Tweening.RotateMode[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(DG.Tweening.ScrambleMode[])) + { + DG.Tweening.ScrambleMode[] array = obj as DG.Tweening.ScrambleMode[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(DG.Tweening.TweenType[])) + { + DG.Tweening.TweenType[] array = obj as DG.Tweening.TweenType[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(DG.Tweening.UpdateType[])) + { + DG.Tweening.UpdateType[] array = obj as DG.Tweening.UpdateType[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(Http.RequestState[])) + { + Http.RequestState[] array = obj as Http.RequestState[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(UnityEngine.Purchasing.ProductType[])) + { + UnityEngine.Purchasing.ProductType[] array = obj as UnityEngine.Purchasing.ProductType[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(BF.BFSlider.FillDirection[])) + { + BF.BFSlider.FillDirection[] array = obj as BF.BFSlider.FillDirection[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(BF.ScrollRectBaseOld.MovementType[])) + { + BF.ScrollRectBaseOld.MovementType[] array = obj as BF.ScrollRectBaseOld.MovementType[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(BF.ScrollRectBaseOld.ScrollbarVisibility[])) + { + BF.ScrollRectBaseOld.ScrollbarVisibility[] array = obj as BF.ScrollRectBaseOld.ScrollbarVisibility[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(BF.NetServiceType[])) + { + BF.NetServiceType[] array = obj as BF.NetServiceType[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(BF.NetIncomingMessageType[])) + { + BF.NetIncomingMessageType[] array = obj as BF.NetIncomingMessageType[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(BF.TouchEventType[])) + { + BF.TouchEventType[] array = obj as BF.TouchEventType[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + else if (type == typeof(BF.SelectEventType[])) + { + BF.SelectEventType[] array = obj as BF.SelectEventType[]; + translator.Get(L, obj_idx, out array[array_idx]); + return true; + } + return false; + } + } +} \ No newline at end of file diff --git a/Assets/XLua/Gen/XLuaGenAutoRegister.cs b/Assets/XLua/Gen/XLuaGenAutoRegister.cs new file mode 100644 index 000000000..62a2fc654 --- /dev/null +++ b/Assets/XLua/Gen/XLuaGenAutoRegister.cs @@ -0,0 +1,2374 @@ +#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 System; +using System.Collections.Generic; +using System.Reflection; + + +namespace XLua.CSObjectWrap +{ + public class XLua_Gen_Initer_Register__ + { + + + static void wrapInit0(LuaEnv luaenv, ObjectTranslator translator) + { + + translator.DelayWrapLoader(typeof(BF.Md5Encrypt), BFMd5EncryptWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.RsaEncrypt), BFRsaEncryptWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.Atlas), BFAtlasWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.SimpleAtlas), BFSimpleAtlasWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFMain), BFBFMainWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFWebRequestManager), BFBFWebRequestManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BIReport), BFBIReportWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.DeepLinkManager), BFDeepLinkManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFEvent), BFBFEventWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFEventBase), BFBFEventBaseWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFVersionInfo), BFBFVersionInfoWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.GameLaunchManager), BFGameLaunchManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.GameLaunchUtils), BFGameLaunchUtilsWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.GameLaunchProcessorBase), BFGameLaunchProcessorBaseWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.LaunchRequester), BFLaunchRequesterWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.CalculateDiffProcessor), BFCalculateDiffProcessorWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.DownloadUpdateProcessor), BFDownloadUpdateProcessorWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.FirstABProcessor), BFFirstABProcessorWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.FixUpProcessor), BFFixUpProcessorWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.LaunchSuccProcessor), BFLaunchSuccProcessorWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.OnGetVersionProcessor), BFOnGetVersionProcessorWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.PreCheckProcessor), BFPreCheckProcessorWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.PrepareProcessor), BFPrepareProcessorWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.RequestLoginCenterConfigProcessor), BFRequestLoginCenterConfigProcessorWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.RequestVersionProcessor), BFRequestVersionProcessorWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.LocalData), BFLocalDataWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFLog), BFBFLogWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.LoomManager), BFLoomManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.LuaManager), BFLuaManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.ManagerBase), BFManagerBaseWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.NetException), BFNetExceptionWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.NetAesEncrypt), BFNetAesEncryptWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.CounterModeCryptoTransform), BFCounterModeCryptoTransformWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.NetMd5Encrypt), BFNetMd5EncryptWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.NetClient), BFNetClientWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.NetConfiguration), BFNetConfigurationWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.NetConnectConfiguration), BFNetConnectConfigurationWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.NetErrorCode), BFNetErrorCodeWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.NetManager), BFNetManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.OneShotManager), BFOneShotManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.GameObjectPool), BFGameObjectPoolWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.PoolManager), BFPoolManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.RenderManager), BFRenderManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.AssetBundleConfigCollection), BFAssetBundleConfigCollectionWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.LanguageConfig), BFLanguageConfigWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.AssetBundleConfig), BFAssetBundleConfigWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.AssetBundleLoader), BFAssetBundleLoaderWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.AssetBundleObject), BFAssetBundleObjectWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.AssetLoader), BFAssetLoaderWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.AssetObject), BFAssetObjectWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.AssetObjectBase), BFAssetObjectBaseWrap.__Register); + + } + + static void wrapInit1(LuaEnv luaenv, ObjectTranslator translator) + { + + translator.DelayWrapLoader(typeof(BF.LoaderBase), BFLoaderBaseWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.ResourceManager), BFResourceManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.SafeAreaManager), BFSafeAreaManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFAccountInfo), BFBFAccountInfoWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFAdmobSDKManager), BFBFAdmobSDKManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFHWAdSDKManager), BFBFHWAdSDKManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFHWPaySDKManager), BFBFHWPaySDKManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFLoginInfo), BFBFLoginInfoWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFLoginSDKManager), BFBFLoginSDKManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFNativeSDKMessage), BFBFNativeSDKMessageWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFNativeSDKManager), BFBFNativeSDKManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFPaySDKManager), BFBFPaySDKManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFRuPaySDKManager), BFBFRuPaySDKManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFThirdReportSDKManager), BFBFThirdReportSDKManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFUMPManager), BFBFUMPManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.NotchScreenInfo), BFNotchScreenInfoWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.DZSDKManager), BFDZSDKManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.NativeUtils), BFNativeUtilsWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.NotificationInfo), BFNotificationInfoWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.NotificationSDKManager), BFNotificationSDKManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFParseClientManager), BFBFParseClientManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.SDKManager), BFSDKManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.SocketChannel), BFSocketChannelWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.Rc4Object), BFRc4ObjectWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.SocketChannelHelper), BFSocketChannelHelperWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.SocketChannelManager), BFSocketChannelManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.AesEncrypt), BFAesEncryptWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.Rc4Encrypt), BFRc4EncryptWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.ResourcesProtect), BFResourcesProtectWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.SocketManager), BFSocketManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.SoundManager), BFSoundManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.Task), BFTaskWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.Delayed), BFDelayedWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.TaskManager), BFTaskManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.TimeLineItem), BFTimeLineItemWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.TimeLineManager), BFTimeLineManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFFinger), BFBFFingerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFFingerSnapshot), BFBFFingerSnapshotWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFGesture), BFBFGestureWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFTouchManager), BFBFTouchManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.URPManager), BFURPManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BattleControlBg), BFBattleControlBgWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BattleUnitAttr), BFBattleUnitAttrWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.DrawBezierLine), BFDrawBezierLineWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BaseSortingOrderHelper), BFBaseSortingOrderHelperWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.CameraHelper), BFCameraHelperWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.CanvasSortingOrderHelper), BFCanvasSortingOrderHelperWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.CharacterObjectInfo), BFCharacterObjectInfoWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.CharacterAnimationInfo), BFCharacterAnimationInfoWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.CharacterHelper), BFCharacterHelperWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.CharacterSpineObjectInfo), BFCharacterSpineObjectInfoWrap.__Register); + + } + + static void wrapInit2(LuaEnv luaenv, ObjectTranslator translator) + { + + translator.DelayWrapLoader(typeof(BF.CharacterSpineHelper), BFCharacterSpineHelperWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.DreamlandInstancingHelper), BFDreamlandInstancingHelperWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.EffectHelper), BFEffectHelperWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.GlobalInfo), BFGlobalInfoWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.GlobalHelper), BFGlobalHelperWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.NodeHelper), BFNodeHelperWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.GameObjectInfo), BFGameObjectInfoWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.PrefabHelper), BFPrefabHelperWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.ShowDebugText), BFShowDebugTextWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.ShowFPS), BFShowFPSWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.TimelineEventItem), BFTimelineEventItemWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.TimelineHelper), BFTimelineHelperWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.TimelineSortingOderHelper), BFTimelineSortingOderHelperWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.UICoordinateHelper), BFUICoordinateHelperWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.NotchScreenNode), BFNotchScreenNodeWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.UIHelper), BFUIHelperWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.UISpineHelper), BFUISpineHelperWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.WeaponHelper), BFWeaponHelperWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.SkillSectorMesh), BFSkillSectorMeshWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.AbsPostEffect), BFAbsPostEffectWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.PostEffectBehaviour), BFPostEffectBehaviourWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.PostEffectBloom), BFPostEffectBloomWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.PostEffectContext), BFPostEffectContextWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.PostEffectFxaa), BFPostEffectFxaaWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.PostEffectRadialBlur), BFPostEffectRadialBlurWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.PostEffectVividBloom), BFPostEffectVividBloomWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.Outline), BFOutlineWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.MultipleSpriteAnimation), BFMultipleSpriteAnimationWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFTouchSelectable), BFBFTouchSelectableWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.CellDragEvent), BFCellDragEventWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.DragEventSync), BFDragEventSyncWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.EliminationTouchEvent), BFEliminationTouchEventWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.UIDragEvent), BFUIDragEventWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.UITouchEvent), BFUITouchEventWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFCircleLayout), BFBFCircleLayoutWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFGridLayout), BFBFGridLayoutWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFHorizontalOrVerticalLayout), BFBFHorizontalOrVerticalLayoutWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFLayoutBase), BFBFLayoutBaseWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFCell), BFBFCellWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFScrollRectBase), BFBFScrollRectBaseWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFScrollRectCommon), BFBFScrollRectCommonWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFScrollRectGrid), BFBFScrollRectGridWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFScrollRectMultCell), BFBFScrollRectMultCellWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFScrollRectMultSize), BFBFScrollRectMultSizeWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.HorizontalScrollRectOld), BFHorizontalScrollRectOldWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.ScrollRectBaseOld), BFScrollRectBaseOldWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.VerticalScrollRectOld), BFVerticalScrollRectOldWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.EmojiGraphic), BFEmojiGraphicWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.MeshInfo), BFMeshInfoWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.InlineText), BFInlineTextWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.EmojiInfo), BFEmojiInfoWrap.__Register); + + } + + static void wrapInit3(LuaEnv luaenv, ObjectTranslator translator) + { + + translator.DelayWrapLoader(typeof(BF.HrefInfo), BFHrefInfoWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.UVAnimationGraphic), BFUVAnimationGraphicWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.EmptyRaycast), BFEmptyRaycastWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.Mirror), BFMirrorWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.CellObj), BFCellObjWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.ScrollRectCenter), BFScrollRectCenterWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.ScrollRectCenterController), BFScrollRectCenterControllerWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.TutorialClickArea), BFTutorialClickAreaWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.UIDynamicBrightEffect), BFUIDynamicBrightEffectWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.UIDynamicShinyEffect), BFUIDynamicShinyEffectWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFGraphicFlip), BFBFGraphicFlipWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFSlider), BFBFSliderWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFUnitySlider), BFBFUnitySliderWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.RawImageGrid), BFRawImageGridWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.UIEraserTexture), BFUIEraserTextureWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFPlatform), BFBFPlatformWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFGateInfo), BFBFGateInfoWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFHttpsInfo), BFBFHttpsInfoWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.CombineURL), BFCombineURLWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFLanguageInfo), BFBFLanguageInfoWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.GameConst), BFGameConstWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.StringConst), BFStringConstWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.ExtensionMethods), BFExtensionMethodsWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.TimeHelper), BFTimeHelperWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.Utils), BFUtilsWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFNativeSDKManager.NativeResultMsg), BFBFNativeSDKManagerNativeResultMsgWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.SocketChannel.NetPack), BFSocketChannelNetPackWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.TimeLineItem.FrameData), BFTimeLineItemFrameDataWrap.__Register); + + + translator.DelayWrapLoader(typeof(CloudControl), CloudControlWrap.__Register); + + + translator.DelayWrapLoader(typeof(AdManager), AdManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(AFInAppEventParameterName), AFInAppEventParameterNameWrap.__Register); + + + translator.DelayWrapLoader(typeof(AFInAppEventType), AFInAppEventTypeWrap.__Register); + + + translator.DelayWrapLoader(typeof(ProductInfo), ProductInfoWrap.__Register); + + + translator.DelayWrapLoader(typeof(IAPManager), IAPManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(FunctionRequest), FunctionRequestWrap.__Register); + + + translator.DelayWrapLoader(typeof(IAPRequest), IAPRequestWrap.__Register); + + + translator.DelayWrapLoader(typeof(StorageRequest), StorageRequestWrap.__Register); + + + translator.DelayWrapLoader(typeof(UsersRequest), UsersRequestWrap.__Register); + + + translator.DelayWrapLoader(typeof(ParticleUVAnimation), ParticleUVAnimationWrap.__Register); + + + translator.DelayWrapLoader(typeof(UIImageSheetAnimation), UIImageSheetAnimationWrap.__Register); + + + translator.DelayWrapLoader(typeof(CameraAdjust), CameraAdjustWrap.__Register); + + + translator.DelayWrapLoader(typeof(FixRectWidthByString), FixRectWidthByStringWrap.__Register); + + + translator.DelayWrapLoader(typeof(TMP_AnimationCurve), TMP_AnimationCurveWrap.__Register); + + + translator.DelayWrapLoader(typeof(TMP_Curve), TMP_CurveWrap.__Register); + + + translator.DelayWrapLoader(typeof(UIOutlineEffect), UIOutlineEffectWrap.__Register); + + + translator.DelayWrapLoader(typeof(UIResGhostTweenEffect), UIResGhostTweenEffectWrap.__Register); + + + translator.DelayWrapLoader(typeof(MonkeyPost), MonkeyPostWrap.__Register); + + + translator.DelayWrapLoader(typeof(UIInputHelper), UIInputHelperWrap.__Register); + + + translator.DelayWrapLoader(typeof(FBWindowsA2UNotificationsManager), FBWindowsA2UNotificationsManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(FBWindowsADSManager), FBWindowsADSManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(FBWindowsExampleTabsManager), FBWindowsExampleTabsManagerWrap.__Register); + + } + + static void wrapInit4(LuaEnv luaenv, ObjectTranslator translator) + { + + translator.DelayWrapLoader(typeof(FBWindowsFriendsManager), FBWindowsFriendsManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(FBWindowsGraphAPIManager), FBWindowsGraphAPIManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(FBWindowsInitManager), FBWindowsInitManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(FBWindowsLoginManager), FBWindowsLoginManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(FBWindowsLogsManager), FBWindowsLogsManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(FBWindowsPhysicalGamepadManager), FBWindowsPhysicalGamepadManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(FBWindowsPurchaseManager), FBWindowsPurchaseManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(FBWindowsShareManager), FBWindowsShareManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(FBWindowsSoftKeyboardManager), FBWindowsSoftKeyboardManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(FBWindowsTournamentsManager), FBWindowsTournamentsManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(FBWindowsVirtualGamepadManager), FBWindowsVirtualGamepadManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(IronSourceDemoScript), IronSourceDemoScriptWrap.__Register); + + + translator.DelayWrapLoader(typeof(AdFormat), AdFormatWrap.__Register); + + + translator.DelayWrapLoader(typeof(IronSource), IronSourceWrap.__Register); + + + translator.DelayWrapLoader(typeof(IronSourceAdInfo), IronSourceAdInfoWrap.__Register); + + + translator.DelayWrapLoader(typeof(IronSourceBannerEvents), IronSourceBannerEventsWrap.__Register); + + + translator.DelayWrapLoader(typeof(IronSourceConfig), IronSourceConfigWrap.__Register); + + + translator.DelayWrapLoader(typeof(IronSourceConstants), IronSourceConstantsWrap.__Register); + + + translator.DelayWrapLoader(typeof(IronSourceError), IronSourceErrorWrap.__Register); + + + translator.DelayWrapLoader(typeof(IronSourceEvents), IronSourceEventsWrap.__Register); + + + translator.DelayWrapLoader(typeof(IronSourceEventsDispatcher), IronSourceEventsDispatcherWrap.__Register); + + + translator.DelayWrapLoader(typeof(IronSourceIAgent), IronSourceIAgentWrap.__Register); + + + translator.DelayWrapLoader(typeof(dataSource), dataSourceWrap.__Register); + + + translator.DelayWrapLoader(typeof(IronSourceAdUnits), IronSourceAdUnitsWrap.__Register); + + + translator.DelayWrapLoader(typeof(IronSourceBannerSize), IronSourceBannerSizeWrap.__Register); + + + translator.DelayWrapLoader(typeof(IronSourceBannerPosition), IronSourceBannerPositionWrap.__Register); + + + translator.DelayWrapLoader(typeof(IronSourceImpressionData), IronSourceImpressionDataWrap.__Register); + + + translator.DelayWrapLoader(typeof(IronSourceInitilizer), IronSourceInitilizerWrap.__Register); + + + translator.DelayWrapLoader(typeof(IronSourceInterstitialEvents), IronSourceInterstitialEventsWrap.__Register); + + + translator.DelayWrapLoader(typeof(IronSourceMediationSettings), IronSourceMediationSettingsWrap.__Register); + + + translator.DelayWrapLoader(typeof(IronSourcePlacement), IronSourcePlacementWrap.__Register); + + + translator.DelayWrapLoader(typeof(IronSourceRewardedVideoEvents), IronSourceRewardedVideoEventsWrap.__Register); + + + translator.DelayWrapLoader(typeof(IronSourceSegment), IronSourceSegmentWrap.__Register); + + + translator.DelayWrapLoader(typeof(IronSourceSegmentAndroid), IronSourceSegmentAndroidWrap.__Register); + + + translator.DelayWrapLoader(typeof(IronSourceUtils), IronSourceUtilsWrap.__Register); + + + translator.DelayWrapLoader(typeof(IUnityBanner), IUnityBannerWrap.__Register); + + + translator.DelayWrapLoader(typeof(IUnityImpressionData), IUnityImpressionDataWrap.__Register); + + + translator.DelayWrapLoader(typeof(IUnityInitialization), IUnityInitializationWrap.__Register); + + + translator.DelayWrapLoader(typeof(IUnityInterstitial), IUnityInterstitialWrap.__Register); + + + translator.DelayWrapLoader(typeof(IUnityLevelPlayBanner), IUnityLevelPlayBannerWrap.__Register); + + + translator.DelayWrapLoader(typeof(IUnityLevelPlayInterstitial), IUnityLevelPlayInterstitialWrap.__Register); + + + translator.DelayWrapLoader(typeof(IUnityLevelPlayRewardedVideo), IUnityLevelPlayRewardedVideoWrap.__Register); + + + translator.DelayWrapLoader(typeof(IUnityLevelPlayRewardedVideoManual), IUnityLevelPlayRewardedVideoManualWrap.__Register); + + + translator.DelayWrapLoader(typeof(IUnityOfferwall), IUnityOfferwallWrap.__Register); + + + translator.DelayWrapLoader(typeof(IUnityRewardedVideo), IUnityRewardedVideoWrap.__Register); + + + translator.DelayWrapLoader(typeof(IUnityRewardedVideoManual), IUnityRewardedVideoManualWrap.__Register); + + + translator.DelayWrapLoader(typeof(IUnitySegment), IUnitySegmentWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnsupportedPlatformAgent), UnsupportedPlatformAgentWrap.__Register); + + + translator.DelayWrapLoader(typeof(WaterfallConfiguration), WaterfallConfigurationWrap.__Register); + + + translator.DelayWrapLoader(typeof(TAExample), TAExampleWrap.__Register); + + + translator.DelayWrapLoader(typeof(SignInWithAppleTest_Callbacks), SignInWithAppleTest_CallbacksWrap.__Register); + + } + + static void wrapInit5(LuaEnv luaenv, ObjectTranslator translator) + { + + translator.DelayWrapLoader(typeof(SignInWithAppleTest_EventSystem), SignInWithAppleTest_EventSystemWrap.__Register); + + + translator.DelayWrapLoader(typeof(LuaAsset), LuaAssetWrap.__Register); + + + translator.DelayWrapLoader(typeof(Security.XXTEA), SecurityXXTEAWrap.__Register); + + + translator.DelayWrapLoader(typeof(ThinkingAnalytics.ThinkingAnalyticsEvent), ThinkingAnalyticsThinkingAnalyticsEventWrap.__Register); + + + translator.DelayWrapLoader(typeof(ThinkingAnalytics.TDFirstEvent), ThinkingAnalyticsTDFirstEventWrap.__Register); + + + translator.DelayWrapLoader(typeof(ThinkingAnalytics.TDUpdatableEvent), ThinkingAnalyticsTDUpdatableEventWrap.__Register); + + + translator.DelayWrapLoader(typeof(ThinkingAnalytics.TDOverWritableEvent), ThinkingAnalyticsTDOverWritableEventWrap.__Register); + + + translator.DelayWrapLoader(typeof(ThinkingAnalytics.TDPresetProperties), ThinkingAnalyticsTDPresetPropertiesWrap.__Register); + + + translator.DelayWrapLoader(typeof(ThinkingAnalytics.ThinkingAnalyticsAPI), ThinkingAnalyticsThinkingAnalyticsAPIWrap.__Register); + + + translator.DelayWrapLoader(typeof(ThinkingAnalytics.Wrapper.ThinkingAnalyticsWrapper), ThinkingAnalyticsWrapperThinkingAnalyticsWrapperWrap.__Register); + + + translator.DelayWrapLoader(typeof(ThinkingAnalytics.Utils.TD_Log), ThinkingAnalyticsUtilsTD_LogWrap.__Register); + + + translator.DelayWrapLoader(typeof(ThinkingAnalytics.Utils.TD_MiniJSON), ThinkingAnalyticsUtilsTD_MiniJSONWrap.__Register); + + + translator.DelayWrapLoader(typeof(ThinkingAnalytics.Utils.TD_PropertiesChecker), ThinkingAnalyticsUtilsTD_PropertiesCheckerWrap.__Register); + + + translator.DelayWrapLoader(typeof(ThinkingAnalytics.TaException.ThinkingSDKExceptionHandler), ThinkingAnalyticsTaExceptionThinkingSDKExceptionHandlerWrap.__Register); + + + translator.DelayWrapLoader(typeof(IronSourceJSON.Json), IronSourceJSONJsonWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.DOTweenModuleAudio), DGTweeningDOTweenModuleAudioWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.DOTweenModuleSprite), DGTweeningDOTweenModuleSpriteWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.DOTweenModuleUI), DGTweeningDOTweenModuleUIWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.DOTweenModuleUnityVersion), DGTweeningDOTweenModuleUnityVersionWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.DOTweenCYInstruction), DGTweeningDOTweenCYInstructionWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.DOTweenModuleUtils), DGTweeningDOTweenModuleUtilsWrap.__Register); + + + translator.DelayWrapLoader(typeof(com.adjust.sdk.JSONNode), comadjustsdkJSONNodeWrap.__Register); + + + translator.DelayWrapLoader(typeof(com.adjust.sdk.JSONArray), comadjustsdkJSONArrayWrap.__Register); + + + translator.DelayWrapLoader(typeof(com.adjust.sdk.JSONClass), comadjustsdkJSONClassWrap.__Register); + + + translator.DelayWrapLoader(typeof(com.adjust.sdk.JSONData), comadjustsdkJSONDataWrap.__Register); + + + translator.DelayWrapLoader(typeof(com.adjust.sdk.JSON), comadjustsdkJSONWrap.__Register); + + + translator.DelayWrapLoader(typeof(com.adjust.sdk.Adjust), comadjustsdkAdjustWrap.__Register); + + + translator.DelayWrapLoader(typeof(com.adjust.sdk.AdjustAdRevenue), comadjustsdkAdjustAdRevenueWrap.__Register); + + + translator.DelayWrapLoader(typeof(com.adjust.sdk.AdjustAppStoreSubscription), comadjustsdkAdjustAppStoreSubscriptionWrap.__Register); + + + translator.DelayWrapLoader(typeof(com.adjust.sdk.AdjustAttribution), comadjustsdkAdjustAttributionWrap.__Register); + + + translator.DelayWrapLoader(typeof(com.adjust.sdk.AdjustConfig), comadjustsdkAdjustConfigWrap.__Register); + + + translator.DelayWrapLoader(typeof(com.adjust.sdk.AdjustEnvironmentExtension), comadjustsdkAdjustEnvironmentExtensionWrap.__Register); + + + translator.DelayWrapLoader(typeof(com.adjust.sdk.AdjustEvent), comadjustsdkAdjustEventWrap.__Register); + + + translator.DelayWrapLoader(typeof(com.adjust.sdk.AdjustEventFailure), comadjustsdkAdjustEventFailureWrap.__Register); + + + translator.DelayWrapLoader(typeof(com.adjust.sdk.AdjustEventSuccess), comadjustsdkAdjustEventSuccessWrap.__Register); + + + translator.DelayWrapLoader(typeof(com.adjust.sdk.AdjustLogLevelExtension), comadjustsdkAdjustLogLevelExtensionWrap.__Register); + + + translator.DelayWrapLoader(typeof(com.adjust.sdk.AdjustPlayStoreSubscription), comadjustsdkAdjustPlayStoreSubscriptionWrap.__Register); + + + translator.DelayWrapLoader(typeof(com.adjust.sdk.AdjustSessionFailure), comadjustsdkAdjustSessionFailureWrap.__Register); + + + translator.DelayWrapLoader(typeof(com.adjust.sdk.AdjustSessionSuccess), comadjustsdkAdjustSessionSuccessWrap.__Register); + + + translator.DelayWrapLoader(typeof(com.adjust.sdk.AdjustThirdPartySharing), comadjustsdkAdjustThirdPartySharingWrap.__Register); + + + translator.DelayWrapLoader(typeof(com.adjust.sdk.AdjustUrlStrategyExtension), comadjustsdkAdjustUrlStrategyExtensionWrap.__Register); + + + translator.DelayWrapLoader(typeof(com.adjust.sdk.AdjustUtils), comadjustsdkAdjustUtilsWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Purchasing.Security.GooglePlayTangle), UnityEnginePurchasingSecurityGooglePlayTangleWrap.__Register); + + + translator.DelayWrapLoader(typeof(Http.HttpDebug), HttpHttpDebugWrap.__Register); + + + translator.DelayWrapLoader(typeof(Http.HttpManager), HttpHttpManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(Http.SingleHttpExtends), HttpSingleHttpExtendsWrap.__Register); + + + translator.DelayWrapLoader(typeof(Http.RequestData), HttpRequestDataWrap.__Register); + + + translator.DelayWrapLoader(typeof(Http.ResultInfo), HttpResultInfoWrap.__Register); + + + translator.DelayWrapLoader(typeof(Http.SingleHttp), HttpSingleHttpWrap.__Register); + + + translator.DelayWrapLoader(typeof(Facebook.MiniJSON.Json), FacebookMiniJSONJsonWrap.__Register); + + + translator.DelayWrapLoader(typeof(Facebook.MiniJSON.MiniJsonUtil), FacebookMiniJSONMiniJsonUtilWrap.__Register); + + } + + static void wrapInit6(LuaEnv luaenv, ObjectTranslator translator) + { + + translator.DelayWrapLoader(typeof(BF.NativeCore.ThirdPlatform.AppsFlyerSdk), BFNativeCoreThirdPlatformAppsFlyerSdkWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.NativeCore.ThirdPlatform.FacebookSdk), BFNativeCoreThirdPlatformFacebookSdkWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.NativeCore.ThirdPlatform.ThinkingAnalyticsSdk), BFNativeCoreThirdPlatformThinkingAnalyticsSdkWrap.__Register); + + + translator.DelayWrapLoader(typeof(UIImageSheetAnimation.AnimationType), UIImageSheetAnimationAnimationTypeWrap.__Register); + + + translator.DelayWrapLoader(typeof(UIImageSheetAnimation.TimeType), UIImageSheetAnimationTimeTypeWrap.__Register); + + + translator.DelayWrapLoader(typeof(UIImageSheetAnimation.StartFrameType), UIImageSheetAnimationStartFrameTypeWrap.__Register); + + + translator.DelayWrapLoader(typeof(WaterfallConfiguration.WaterfallConfigurationBuilder), WaterfallConfigurationWaterfallConfigurationBuilderWrap.__Register); + + + translator.DelayWrapLoader(typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.Token), ThinkingAnalyticsThinkingAnalyticsAPITokenWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.DOTweenModuleUI.Utils), DGTweeningDOTweenModuleUIUtilsWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.DOTweenCYInstruction.WaitForCompletion), DGTweeningDOTweenCYInstructionWaitForCompletionWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.DOTweenCYInstruction.WaitForRewind), DGTweeningDOTweenCYInstructionWaitForRewindWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.DOTweenCYInstruction.WaitForKill), DGTweeningDOTweenCYInstructionWaitForKillWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.DOTweenCYInstruction.WaitForElapsedLoops), DGTweeningDOTweenCYInstructionWaitForElapsedLoopsWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.DOTweenCYInstruction.WaitForPosition), DGTweeningDOTweenCYInstructionWaitForPositionWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.DOTweenCYInstruction.WaitForStart), DGTweeningDOTweenCYInstructionWaitForStartWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.DOTweenModuleUtils.Physics), DGTweeningDOTweenModuleUtilsPhysicsWrap.__Register); + + + translator.DelayWrapLoader(typeof(object), SystemObjectWrap.__Register); + + + translator.DelayWrapLoader(typeof(System.ValueType), SystemValueTypeWrap.__Register); + + + translator.DelayWrapLoader(typeof(System.Reflection.BindingFlags), SystemReflectionBindingFlagsWrap.__Register); + + + translator.DelayWrapLoader(typeof(System.Uri), SystemUriWrap.__Register); + + + translator.DelayWrapLoader(typeof(System.Enum), SystemEnumWrap.__Register); + + + translator.DelayWrapLoader(typeof(System.DateTime), SystemDateTimeWrap.__Register); + + + translator.DelayWrapLoader(typeof(System.DateTimeOffset), SystemDateTimeOffsetWrap.__Register); + + + translator.DelayWrapLoader(typeof(System.IO.File), SystemIOFileWrap.__Register); + + + translator.DelayWrapLoader(typeof(System.DBNull), SystemDBNullWrap.__Register); + + + translator.DelayWrapLoader(typeof(System.Convert), SystemConvertWrap.__Register); + + + translator.DelayWrapLoader(typeof(System.DayOfWeek), SystemDayOfWeekWrap.__Register); + + + translator.DelayWrapLoader(typeof(System.Net.NetworkInformation.Ping), SystemNetNetworkInformationPingWrap.__Register); + + + translator.DelayWrapLoader(typeof(System.Net.NetworkInformation.IPStatus), SystemNetNetworkInformationIPStatusWrap.__Register); + + + translator.DelayWrapLoader(typeof(System.Net.NetworkInformation.PingCompletedEventArgs), SystemNetNetworkInformationPingCompletedEventArgsWrap.__Register); + + + translator.DelayWrapLoader(typeof(System.Net.NetworkInformation.PingReply), SystemNetNetworkInformationPingReplyWrap.__Register); + + + translator.DelayWrapLoader(typeof(System.ComponentModel.AsyncCompletedEventArgs), SystemComponentModelAsyncCompletedEventArgsWrap.__Register); + + + translator.DelayWrapLoader(typeof(System.ComponentModel.Component), SystemComponentModelComponentWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Events.UnityEvent), UnityEngineEventsUnityEvent_1_SystemSingle_Wrap.__Register); + + + translator.DelayWrapLoader(typeof(System.Collections.Generic.List), SystemCollectionsGenericList_1_SystemInt32_Wrap.__Register); + + + translator.DelayWrapLoader(typeof(System.Collections.Generic.List), SystemCollectionsGenericList_1_SystemSingle_Wrap.__Register); + + + translator.DelayWrapLoader(typeof(System.Collections.Generic.List), SystemCollectionsGenericList_1_SystemString_Wrap.__Register); + + + translator.DelayWrapLoader(typeof(System.Collections.Generic.List), SystemCollectionsGenericList_1_TMProTMP_FontAsset_Wrap.__Register); + + + translator.DelayWrapLoader(typeof(System.Collections.Generic.List), SystemCollectionsGenericList_1_UnityEngineCamera_Wrap.__Register); + + + translator.DelayWrapLoader(typeof(System.Collections.Generic.List>), SystemCollectionsGenericList_1_SystemCollectionsGenericList_1_SystemString__Wrap.__Register); + + + translator.DelayWrapLoader(typeof(System.Collections.Generic.List), SystemCollectionsGenericList_1_BFBFFinger_Wrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.Core.TweenerCore), DGTweeningCoreTweenerCore_3_UnityEngineColorUnityEngineColorDGTweeningPluginsOptionsColorOptions_Wrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.Core.TweenerCore), DGTweeningCoreTweenerCore_3_UnityEngineVector2UnityEngineVector2DGTweeningPluginsOptionsVectorOptions_Wrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Camera), UnityEngineCameraWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Camera.GateFitMode), UnityEngineCameraGateFitModeWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Camera.GateFitParameters), UnityEngineCameraGateFitParametersWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Camera.StereoscopicEye), UnityEngineCameraStereoscopicEyeWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Camera.MonoOrStereoscopicEye), UnityEngineCameraMonoOrStereoscopicEyeWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Camera.FieldOfViewAxis), UnityEngineCameraFieldOfViewAxisWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Camera.RenderRequest), UnityEngineCameraRenderRequestWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Camera.RenderRequestMode), UnityEngineCameraRenderRequestModeWrap.__Register); + + } + + static void wrapInit7(LuaEnv luaenv, ObjectTranslator translator) + { + + translator.DelayWrapLoader(typeof(UnityEngine.Camera.RenderRequestOutputSpace), UnityEngineCameraRenderRequestOutputSpaceWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Camera.SceneViewFilterMode), UnityEngineCameraSceneViewFilterModeWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.TextCore.FaceInfo), UnityEngineTextCoreFaceInfoWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Rendering.LightShadowResolution), UnityEngineRenderingLightShadowResolutionWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.RenderTextureFormat), UnityEngineRenderTextureFormatWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.RenderTextureReadWrite), UnityEngineRenderTextureReadWriteWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.RigidbodyConstraints), UnityEngineRigidbodyConstraintsWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.TransparencySortMode), UnityEngineTransparencySortModeWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.SystemInfo), UnityEngineSystemInfoWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Object), UnityEngineObjectWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Rect), UnityEngineRectWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Vector2), UnityEngineVector2Wrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Vector3), UnityEngineVector3Wrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Vector4), UnityEngineVector4Wrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Quaternion), UnityEngineQuaternionWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Matrix4x4), UnityEngineMatrix4x4Wrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Color), UnityEngineColorWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Ray), UnityEngineRayWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Bounds), UnityEngineBoundsWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Ray2D), UnityEngineRay2DWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Time), UnityEngineTimeWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Motion), UnityEngineMotionWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.GameObject), UnityEngineGameObjectWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Component), UnityEngineComponentWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Behaviour), UnityEngineBehaviourWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.EventSystems.UIBehaviour), UnityEngineEventSystemsUIBehaviourWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Transform), UnityEngineTransformWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.RectTransform), UnityEngineRectTransformWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.RectTransform.Axis), UnityEngineRectTransformAxisWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.RectTransform.Edge), UnityEngineRectTransformEdgeWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Resources), UnityEngineResourcesWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.TextAsset), UnityEngineTextAssetWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Keyframe), UnityEngineKeyframeWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Sprite), UnityEngineSpriteWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.AnimatorStateInfo), UnityEngineAnimatorStateInfoWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.AnimatorCullingMode), UnityEngineAnimatorCullingModeWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Animation), UnityEngineAnimationWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.AnimationCurve), UnityEngineAnimationCurveWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.AnimationClip), UnityEngineAnimationClipWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.MonoBehaviour), UnityEngineMonoBehaviourWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystem), UnityEngineParticleSystemWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystem.MainModule), UnityEngineParticleSystemMainModuleWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystem.EmissionModule), UnityEngineParticleSystemEmissionModuleWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystem.ShapeModule), UnityEngineParticleSystemShapeModuleWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystem.VelocityOverLifetimeModule), UnityEngineParticleSystemVelocityOverLifetimeModuleWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystem.LimitVelocityOverLifetimeModule), UnityEngineParticleSystemLimitVelocityOverLifetimeModuleWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystem.InheritVelocityModule), UnityEngineParticleSystemInheritVelocityModuleWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystem.ForceOverLifetimeModule), UnityEngineParticleSystemForceOverLifetimeModuleWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystem.ColorOverLifetimeModule), UnityEngineParticleSystemColorOverLifetimeModuleWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystem.ColorBySpeedModule), UnityEngineParticleSystemColorBySpeedModuleWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystem.SizeOverLifetimeModule), UnityEngineParticleSystemSizeOverLifetimeModuleWrap.__Register); + + } + + static void wrapInit8(LuaEnv luaenv, ObjectTranslator translator) + { + + translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystem.SizeBySpeedModule), UnityEngineParticleSystemSizeBySpeedModuleWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystem.RotationBySpeedModule), UnityEngineParticleSystemRotationBySpeedModuleWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystem.RotationOverLifetimeModule), UnityEngineParticleSystemRotationOverLifetimeModuleWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystem.ExternalForcesModule), UnityEngineParticleSystemExternalForcesModuleWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystem.NoiseModule), UnityEngineParticleSystemNoiseModuleWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystem.CollisionModule), UnityEngineParticleSystemCollisionModuleWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystem.TriggerModule), UnityEngineParticleSystemTriggerModuleWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystem.SubEmittersModule), UnityEngineParticleSystemSubEmittersModuleWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystem.TextureSheetAnimationModule), UnityEngineParticleSystemTextureSheetAnimationModuleWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystem.LightsModule), UnityEngineParticleSystemLightsModuleWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystem.TrailModule), UnityEngineParticleSystemTrailModuleWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystem.CustomDataModule), UnityEngineParticleSystemCustomDataModuleWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystem.MinMaxCurve), UnityEngineParticleSystemMinMaxCurveWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystem.Particle), UnityEngineParticleSystemParticleWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystem.Burst), UnityEngineParticleSystemBurstWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystem.MinMaxGradient), UnityEngineParticleSystemMinMaxGradientWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystem.EmitParams), UnityEngineParticleSystemEmitParamsWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystemRenderer), UnityEngineParticleSystemRendererWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.MeshRenderer), UnityEngineMeshRendererWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.SkinnedMeshRenderer), UnityEngineSkinnedMeshRendererWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Renderer), UnityEngineRendererWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Light), UnityEngineLightWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Mathf), UnityEngineMathfWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Debug), UnityEngineDebugWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Screen), UnityEngineScreenWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Resolution), UnityEngineResolutionWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Shader), UnityEngineShaderWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ShaderVariantCollection), UnityEngineShaderVariantCollectionWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Playables.PlayableDirector), UnityEnginePlayablesPlayableDirectorWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Playables.PlayableAsset), UnityEnginePlayablesPlayableAssetWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Playables.Playable), UnityEnginePlayablesPlayableWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.RuntimeAnimatorController), UnityEngineRuntimeAnimatorControllerWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Application), UnityEngineApplicationWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.SystemLanguage), UnityEngineSystemLanguageWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.AudioClip), UnityEngineAudioClipWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.SceneManagement.SceneManager), UnityEngineSceneManagementSceneManagerWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.SceneManagement.Scene), UnityEngineSceneManagementSceneWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.AssetBundle), UnityEngineAssetBundleWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.AssetBundleRequest), UnityEngineAssetBundleRequestWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.AudioSource), UnityEngineAudioSourceWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.AsyncOperation), UnityEngineAsyncOperationWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Avatar), UnityEngineAvatarWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Animator), UnityEngineAnimatorWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Events.UnityEvent), UnityEngineEventsUnityEventWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Events.UnityEvent), UnityEngineEventsUnityEvent_1_SystemString_Wrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Events.UnityEvent), UnityEngineEventsUnityEvent_1_UnityEngineVector2_Wrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Events.UnityEvent), UnityEngineEventsUnityEvent_1_SystemInt32_Wrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Events.UnityEvent), UnityEngineEventsUnityEvent_1_SystemInt64_Wrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Events.UnityEventBase), UnityEngineEventsUnityEventBaseWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.LayerMask), UnityEngineLayerMaskWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.RenderTextureDescriptor), UnityEngineRenderTextureDescriptorWrap.__Register); + + } + + static void wrapInit9(LuaEnv luaenv, ObjectTranslator translator) + { + + translator.DelayWrapLoader(typeof(UnityEngine.Material), UnityEngineMaterialWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.MaterialPropertyBlock), UnityEngineMaterialPropertyBlockWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.SpriteRenderer), UnityEngineSpriteRendererWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Mesh), UnityEngineMeshWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.MeshFilter), UnityEngineMeshFilterWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Rendering.ShadowCastingMode), UnityEngineRenderingShadowCastingModeWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Video.VideoClip), UnityEngineVideoVideoClipWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Video.VideoPlayer), UnityEngineVideoVideoPlayerWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.RenderSettings), UnityEngineRenderSettingsWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Canvas), UnityEngineCanvasWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.CanvasGroup), UnityEngineCanvasGroupWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.CanvasRenderer), UnityEngineCanvasRendererWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.LineRenderer), UnityEngineLineRendererWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Texture2D), UnityEngineTexture2DWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Texture2D.EXRFlags), UnityEngineTexture2DEXRFlagsWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Font), UnityEngineFontWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.RenderTexture), UnityEngineRenderTextureWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Texture), UnityEngineTextureWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Graphics), UnityEngineGraphicsWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Input), UnityEngineInputWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.KeyCode), UnityEngineKeyCodeWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.PlayerPrefs), UnityEnginePlayerPrefsWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ShaderVariantCollection.ShaderVariant), UnityEngineShaderVariantCollectionShaderVariantWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.NetworkReachability), UnityEngineNetworkReachabilityWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.RuntimePlatform), UnityEngineRuntimePlatformWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Rendering.CompareFunction), UnityEngineRenderingCompareFunctionWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.TextAnchor), UnityEngineTextAnchorWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.LightProbes), UnityEngineLightProbesWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.BoxCollider), UnityEngineBoxColliderWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.RaycastHit), UnityEngineRaycastHitWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.LightmapSettings), UnityEngineLightmapSettingsWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.LightmapData), UnityEngineLightmapDataWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ReflectionProbe), UnityEngineReflectionProbeWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.BatteryStatus), UnityEngineBatteryStatusWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Rigidbody), UnityEngineRigidbodyWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.SphereCollider), UnityEngineSphereColliderWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.ScriptableObject), UnityEngineScriptableObjectWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Physics), UnityEnginePhysicsWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.PhysicMaterial), UnityEnginePhysicMaterialWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.MeshCollider), UnityEngineMeshColliderWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.CanvasScaler), UnityEngineUICanvasScalerWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.Dropdown), UnityEngineUIDropdownWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.Dropdown.OptionData), UnityEngineUIDropdownOptionDataWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.Dropdown.OptionDataList), UnityEngineUIDropdownOptionDataListWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.Dropdown.DropdownEvent), UnityEngineUIDropdownDropdownEventWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.Graphic), UnityEngineUIGraphicWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.GraphicRaycaster), UnityEngineUIGraphicRaycasterWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.GraphicRaycaster.BlockingObjects), UnityEngineUIGraphicRaycasterBlockingObjectsWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.Image), UnityEngineUIImageWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.Image.Type), UnityEngineUIImageTypeWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.Image.FillMethod), UnityEngineUIImageFillMethodWrap.__Register); + + } + + static void wrapInit10(LuaEnv luaenv, ObjectTranslator translator) + { + + translator.DelayWrapLoader(typeof(UnityEngine.UI.Image.OriginHorizontal), UnityEngineUIImageOriginHorizontalWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.Image.OriginVertical), UnityEngineUIImageOriginVerticalWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.Image.Origin90), UnityEngineUIImageOrigin90Wrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.Image.Origin180), UnityEngineUIImageOrigin180Wrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.Image.Origin360), UnityEngineUIImageOrigin360Wrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.Button), UnityEngineUIButtonWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.Button.ButtonClickedEvent), UnityEngineUIButtonButtonClickedEventWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.InputField), UnityEngineUIInputFieldWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.InputField.ContentType), UnityEngineUIInputFieldContentTypeWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.InputField.InputType), UnityEngineUIInputFieldInputTypeWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.InputField.EndEditEvent), UnityEngineUIInputFieldEndEditEventWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.InputField.CharacterValidation), UnityEngineUIInputFieldCharacterValidationWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.InputField.LineType), UnityEngineUIInputFieldLineTypeWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.InputField.SubmitEvent), UnityEngineUIInputFieldSubmitEventWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.InputField.OnChangeEvent), UnityEngineUIInputFieldOnChangeEventWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.Mask), UnityEngineUIMaskWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.MaskableGraphic), UnityEngineUIMaskableGraphicWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.MaskableGraphic.CullStateChangedEvent), UnityEngineUIMaskableGraphicCullStateChangedEventWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.MaskUtilities), UnityEngineUIMaskUtilitiesWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.RawImage), UnityEngineUIRawImageWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.RectMask2D), UnityEngineUIRectMask2DWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.Scrollbar), UnityEngineUIScrollbarWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.ScrollRect), UnityEngineUIScrollRectWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.ScrollRect.MovementType), UnityEngineUIScrollRectMovementTypeWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.ScrollRect.ScrollbarVisibility), UnityEngineUIScrollRectScrollbarVisibilityWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.ScrollRect.ScrollRectEvent), UnityEngineUIScrollRectScrollRectEventWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.Selectable), UnityEngineUISelectableWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.Slider), UnityEngineUISliderWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.Slider.Direction), UnityEngineUISliderDirectionWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.Slider.SliderEvent), UnityEngineUISliderSliderEventWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.Text), UnityEngineUITextWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.Toggle), UnityEngineUIToggleWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.Toggle.ToggleTransition), UnityEngineUIToggleToggleTransitionWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.Toggle.ToggleEvent), UnityEngineUIToggleToggleEventWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.ToggleGroup), UnityEngineUIToggleGroupWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.LayoutElement), UnityEngineUILayoutElementWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.GridLayoutGroup), UnityEngineUIGridLayoutGroupWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.GridLayoutGroup.Corner), UnityEngineUIGridLayoutGroupCornerWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.GridLayoutGroup.Axis), UnityEngineUIGridLayoutGroupAxisWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.GridLayoutGroup.Constraint), UnityEngineUIGridLayoutGroupConstraintWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.VerticalLayoutGroup), UnityEngineUIVerticalLayoutGroupWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.UI.LayoutGroup), UnityEngineUILayoutGroupWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.U2D.SpriteAtlas), UnityEngineU2DSpriteAtlasWrap.__Register); + + + translator.DelayWrapLoader(typeof(Spine.TrackEntry), SpineTrackEntryWrap.__Register); + + + translator.DelayWrapLoader(typeof(Spine.SkeletonData), SpineSkeletonDataWrap.__Register); + + + translator.DelayWrapLoader(typeof(Spine.Skeleton), SpineSkeletonWrap.__Register); + + + translator.DelayWrapLoader(typeof(Spine.Slot), SpineSlotWrap.__Register); + + + translator.DelayWrapLoader(typeof(Spine.RegionAttachment), SpineRegionAttachmentWrap.__Register); + + + translator.DelayWrapLoader(typeof(Spine.Animation), SpineAnimationWrap.__Register); + + + translator.DelayWrapLoader(typeof(Spine.AnimationState), SpineAnimationStateWrap.__Register); + + + translator.DelayWrapLoader(typeof(Spine.AnimationStateData), SpineAnimationStateDataWrap.__Register); + + } + + static void wrapInit11(LuaEnv luaenv, ObjectTranslator translator) + { + + translator.DelayWrapLoader(typeof(Spine.AnimationStateData.AnimationPair), SpineAnimationStateDataAnimationPairWrap.__Register); + + + translator.DelayWrapLoader(typeof(Spine.AnimationStateData.AnimationPairComparer), SpineAnimationStateDataAnimationPairComparerWrap.__Register); + + + translator.DelayWrapLoader(typeof(Spine.Unity.SkeletonGraphic), SpineUnitySkeletonGraphicWrap.__Register); + + + translator.DelayWrapLoader(typeof(Spine.Unity.SkeletonAnimation), SpineUnitySkeletonAnimationWrap.__Register); + + + translator.DelayWrapLoader(typeof(Spine.Unity.SkeletonDataAsset), SpineUnitySkeletonDataAssetWrap.__Register); + + + translator.DelayWrapLoader(typeof(Spine.Unity.MeshGenerator), SpineUnityMeshGeneratorWrap.__Register); + + + translator.DelayWrapLoader(typeof(Spine.MeshAttachment), SpineMeshAttachmentWrap.__Register); + + + translator.DelayWrapLoader(typeof(Spine.Unity.MeshGenerator.Settings), SpineUnityMeshGeneratorSettingsWrap.__Register); + + + translator.DelayWrapLoader(typeof(Spine.Unity.SkeletonRenderer), SpineUnitySkeletonRendererWrap.__Register); + + + translator.DelayWrapLoader(typeof(Spine.Unity.SkeletonRenderer.SpriteMaskInteractionMaterials), SpineUnitySkeletonRendererSpriteMaskInteractionMaterialsWrap.__Register); + + + translator.DelayWrapLoader(typeof(Spine.Unity.BoneFollower), SpineUnityBoneFollowerWrap.__Register); + + + translator.DelayWrapLoader(typeof(Spine.Unity.BoneFollowerGraphic), SpineUnityBoneFollowerGraphicWrap.__Register); + + + translator.DelayWrapLoader(typeof(Spine.Unity.BoneFollower.AxisOrientation), SpineUnityBoneFollowerAxisOrientationWrap.__Register); + + + translator.DelayWrapLoader(typeof(Spine.Unity.SkeletonGraphic.LayoutMode), SpineUnitySkeletonGraphicLayoutModeWrap.__Register); + + + translator.DelayWrapLoader(typeof(TMPro.TextAlignmentOptions), TMProTextAlignmentOptionsWrap.__Register); + + + translator.DelayWrapLoader(typeof(TMPro.TMP_FontAsset), TMProTMP_FontAssetWrap.__Register); + + + translator.DelayWrapLoader(typeof(TMPro.TMP_Character), TMProTMP_CharacterWrap.__Register); + + + translator.DelayWrapLoader(typeof(TMPro.TextMeshProUGUI), TMProTextMeshProUGUIWrap.__Register); + + + translator.DelayWrapLoader(typeof(TMPro.TextMeshPro), TMProTextMeshProWrap.__Register); + + + translator.DelayWrapLoader(typeof(TMPro.TMP_Text), TMProTMP_TextWrap.__Register); + + + translator.DelayWrapLoader(typeof(TMPro.TMP_Dropdown), TMProTMP_DropdownWrap.__Register); + + + translator.DelayWrapLoader(typeof(TMPro.TMP_Dropdown.OptionData), TMProTMP_DropdownOptionDataWrap.__Register); + + + translator.DelayWrapLoader(typeof(TMPro.TMP_Dropdown.OptionDataList), TMProTMP_DropdownOptionDataListWrap.__Register); + + + translator.DelayWrapLoader(typeof(TMPro.TMP_Dropdown.DropdownEvent), TMProTMP_DropdownDropdownEventWrap.__Register); + + + translator.DelayWrapLoader(typeof(TMPro.TMP_InputField), TMProTMP_InputFieldWrap.__Register); + + + translator.DelayWrapLoader(typeof(TMPro.TMP_InputField.ContentType), TMProTMP_InputFieldContentTypeWrap.__Register); + + + translator.DelayWrapLoader(typeof(TMPro.TMP_InputField.InputType), TMProTMP_InputFieldInputTypeWrap.__Register); + + + translator.DelayWrapLoader(typeof(TMPro.TMP_InputField.CharacterValidation), TMProTMP_InputFieldCharacterValidationWrap.__Register); + + + translator.DelayWrapLoader(typeof(TMPro.TMP_InputField.LineType), TMProTMP_InputFieldLineTypeWrap.__Register); + + + translator.DelayWrapLoader(typeof(TMPro.TMP_InputField.SubmitEvent), TMProTMP_InputFieldSubmitEventWrap.__Register); + + + translator.DelayWrapLoader(typeof(TMPro.TMP_InputField.OnChangeEvent), TMProTMP_InputFieldOnChangeEventWrap.__Register); + + + translator.DelayWrapLoader(typeof(TMPro.TMP_InputField.SelectionEvent), TMProTMP_InputFieldSelectionEventWrap.__Register); + + + translator.DelayWrapLoader(typeof(TMPro.TMP_InputField.TextSelectionEvent), TMProTMP_InputFieldTextSelectionEventWrap.__Register); + + + translator.DelayWrapLoader(typeof(TMPro.TMP_InputField.TouchScreenKeyboardEvent), TMProTMP_InputFieldTouchScreenKeyboardEventWrap.__Register); + + + translator.DelayWrapLoader(typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.TATimeZone), ThinkingAnalyticsThinkingAnalyticsAPITATimeZoneWrap.__Register); + + + translator.DelayWrapLoader(typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.TAMode), ThinkingAnalyticsThinkingAnalyticsAPITAModeWrap.__Register); + + + translator.DelayWrapLoader(typeof(ThinkingAnalytics.ThinkingAnalyticsAPI.NetworkType), ThinkingAnalyticsThinkingAnalyticsAPINetworkTypeWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.AutoPlay), DGTweeningAutoPlayWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.AxisConstraint), DGTweeningAxisConstraintWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.Ease), DGTweeningEaseWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.LogBehaviour), DGTweeningLogBehaviourWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.LoopType), DGTweeningLoopTypeWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.PathMode), DGTweeningPathModeWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.PathType), DGTweeningPathTypeWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.RotateMode), DGTweeningRotateModeWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.ScrambleMode), DGTweeningScrambleModeWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.TweenType), DGTweeningTweenTypeWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.UpdateType), DGTweeningUpdateTypeWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.DOTween), DGTweeningDOTweenWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.Core.DOTweenComponent), DGTweeningCoreDOTweenComponentWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.Core.TweenerCore), DGTweeningCoreTweenerCore_3_UnityEngineVector3UnityEngineVector3__DGTweeningPluginsOptionsVector3ArrayOptions_Wrap.__Register); + + } + + static void wrapInit12(LuaEnv luaenv, ObjectTranslator translator) + { + + translator.DelayWrapLoader(typeof(DG.Tweening.Core.TweenerCore), DGTweeningCoreTweenerCore_3_UnityEngineQuaternionUnityEngineVector3DGTweeningPluginsOptionsQuaternionOptions_Wrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.Core.TweenerCore), DGTweeningCoreTweenerCore_3_UnityEngineVector3DGTweeningPluginsCorePathCorePathDGTweeningPluginsOptionsPathOptions_Wrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.Core.TweenerCore), DGTweeningCoreTweenerCore_3_SystemSingleSystemSingleDGTweeningPluginsOptionsFloatOptions_Wrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.Core.TweenerCore), DGTweeningCoreTweenerCore_3_UnityEngineVector3UnityEngineVector3DGTweeningPluginsOptionsVectorOptions_Wrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.DOVirtual), DGTweeningDOVirtualWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.EaseFactory), DGTweeningEaseFactoryWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.Tweener), DGTweeningTweenerWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.Tween), DGTweeningTweenWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.Sequence), DGTweeningSequenceWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.TweenParams), DGTweeningTweenParamsWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.Core.ABSSequentiable), DGTweeningCoreABSSequentiableWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.TweenExtensions), DGTweeningTweenExtensionsWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.TweenSettingsExtensions), DGTweeningTweenSettingsExtensionsWrap.__Register); + + + translator.DelayWrapLoader(typeof(DG.Tweening.ShortcutExtensions), DGTweeningShortcutExtensionsWrap.__Register); + + + translator.DelayWrapLoader(typeof(Http.RequestState), HttpRequestStateWrap.__Register); + + + translator.DelayWrapLoader(typeof(BestHTTP.HTTPRequest), BestHTTPHTTPRequestWrap.__Register); + + + translator.DelayWrapLoader(typeof(BestHTTP.HTTPResponse), BestHTTPHTTPResponseWrap.__Register); + + + translator.DelayWrapLoader(typeof(BestHTTP.Connections.HTTP2.HTTP2Response), BestHTTPConnectionsHTTP2HTTP2ResponseWrap.__Register); + + + translator.DelayWrapLoader(typeof(BestHTTP.Forms.HTTPUrlEncodedForm), BestHTTPFormsHTTPUrlEncodedFormWrap.__Register); + + + translator.DelayWrapLoader(typeof(BestHTTP.Forms.HTTPFormBase), BestHTTPFormsHTTPFormBaseWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Purchasing.Product), UnityEnginePurchasingProductWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Purchasing.ProductDefinition), UnityEnginePurchasingProductDefinitionWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Purchasing.ProductMetadata), UnityEnginePurchasingProductMetadataWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Purchasing.ProductType), UnityEnginePurchasingProductTypeWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.MonoSingleton), BFMonoSingleton_1_BFBFMain_Wrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.MonoSingleton), BFMonoSingleton_1_AdManager_Wrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFSlider.FillDirection), BFBFSliderFillDirectionWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.ScrollRectBaseOld.MovementType), BFScrollRectBaseOldMovementTypeWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.ScrollRectBaseOld.ScrollbarVisibility), BFScrollRectBaseOldScrollbarVisibilityWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.NetServiceType), BFNetServiceTypeWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.NetIncomingMessageType), BFNetIncomingMessageTypeWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFEvent>), BFBFEvent_1_SystemCollectionsGenericList_1_BFBFFinger__Wrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFEvent), BFBFEvent_2_BFSelectEventTypeBFBFFinger_Wrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.BFEvent), BFBFEvent_2_BFTouchEventTypeBFBFFinger_Wrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.TouchEventType), BFTouchEventTypeWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.SelectEventType), BFSelectEventTypeWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Purchasing.Security.AppleStoreKitTestTangle), UnityEnginePurchasingSecurityAppleStoreKitTestTangleWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.Purchasing.Security.AppleTangle), UnityEnginePurchasingSecurityAppleTangleWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.SignInWithApple.SignInWithApple.CallbackArgs), UnityEngineSignInWithAppleSignInWithAppleCallbackArgsWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.SignInWithApple.SignInWithAppleEvent), UnityEngineSignInWithAppleSignInWithAppleEventWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.SignInWithApple.SignInWithApple), UnityEngineSignInWithAppleSignInWithAppleWrap.__Register); + + + translator.DelayWrapLoader(typeof(UnityEngine.SignInWithApple.UserInfo), UnityEngineSignInWithAppleUserInfoWrap.__Register); + + + translator.DelayWrapLoader(typeof(BF.EnumFlagsAttribute), BFEnumFlagsAttributeWrap.__Register); + + + + } + + static void Init(LuaEnv luaenv, ObjectTranslator translator) + { + + wrapInit0(luaenv, translator); + + wrapInit1(luaenv, translator); + + wrapInit2(luaenv, translator); + + wrapInit3(luaenv, translator); + + wrapInit4(luaenv, translator); + + wrapInit5(luaenv, translator); + + wrapInit6(luaenv, translator); + + wrapInit7(luaenv, translator); + + wrapInit8(luaenv, translator); + + wrapInit9(luaenv, translator); + + wrapInit10(luaenv, translator); + + wrapInit11(luaenv, translator); + + wrapInit12(luaenv, translator); + + + } + + static XLua_Gen_Initer_Register__() + { + XLua.LuaEnv.AddIniter(Init); + } + + + } + +} +namespace XLua +{ + public partial class ObjectTranslator + { + static XLua.CSObjectWrap.XLua_Gen_Initer_Register__ s_gen_reg_dumb_obj = new XLua.CSObjectWrap.XLua_Gen_Initer_Register__(); + static XLua.CSObjectWrap.XLua_Gen_Initer_Register__ gen_reg_dumb_obj {get{return s_gen_reg_dumb_obj;}} + } + + internal partial class InternalGlobals + { + + delegate DG.Tweening.Core.TweenerCore __GEN_DELEGATE0( UnityEngine.Audio.AudioMixer target, string floatName, float endValue, float duration); + + delegate int __GEN_DELEGATE1( UnityEngine.Audio.AudioMixer target, bool withCallbacks); + + delegate int __GEN_DELEGATE2( UnityEngine.Audio.AudioMixer target, bool complete); + + delegate int __GEN_DELEGATE3( UnityEngine.Audio.AudioMixer target); + + delegate int __GEN_DELEGATE4( UnityEngine.Audio.AudioMixer target, float to, bool andPlay); + + delegate int __GEN_DELEGATE5( UnityEngine.Audio.AudioMixer target); + + delegate int __GEN_DELEGATE6( UnityEngine.Audio.AudioMixer target); + + delegate int __GEN_DELEGATE7( UnityEngine.Audio.AudioMixer target); + + delegate int __GEN_DELEGATE8( UnityEngine.Audio.AudioMixer target); + + delegate int __GEN_DELEGATE9( UnityEngine.Audio.AudioMixer target); + + delegate int __GEN_DELEGATE10( UnityEngine.Audio.AudioMixer target); + + delegate int __GEN_DELEGATE11( UnityEngine.Audio.AudioMixer target); + + delegate int __GEN_DELEGATE12( UnityEngine.Audio.AudioMixer target); + + delegate DG.Tweening.Core.TweenerCore __GEN_DELEGATE13( UnityEngine.UI.Outline target, UnityEngine.Color endValue, float duration); + + delegate DG.Tweening.Core.TweenerCore __GEN_DELEGATE14( UnityEngine.UI.Outline target, float endValue, float duration); + + delegate DG.Tweening.Core.TweenerCore __GEN_DELEGATE15( UnityEngine.UI.Outline target, UnityEngine.Vector2 endValue, float duration); + + delegate string __GEN_DELEGATE16( com.adjust.sdk.AdjustEnvironment adjustEnvironment); + + delegate string __GEN_DELEGATE17( com.adjust.sdk.AdjustLogLevel AdjustLogLevel); + + delegate string __GEN_DELEGATE18( com.adjust.sdk.AdjustLogLevel AdjustLogLevel); + + delegate string __GEN_DELEGATE19( com.adjust.sdk.AdjustUrlStrategy strategy); + + delegate DG.Tweening.Tweener __GEN_DELEGATE20( DG.Tweening.Core.TweenerCore t, bool snapping); + + delegate DG.Tweening.Tweener __GEN_DELEGATE21( DG.Tweening.Core.TweenerCore t, DG.Tweening.AxisConstraint axisConstraint, bool snapping); + + delegate DG.Tweening.Tweener __GEN_DELEGATE22( DG.Tweening.Core.TweenerCore t, bool snapping); + + delegate DG.Tweening.Tweener __GEN_DELEGATE23( DG.Tweening.Core.TweenerCore t, bool richTextEnabled, DG.Tweening.ScrambleMode scrambleMode, string scrambleChars); + + delegate DG.Tweening.Tweener __GEN_DELEGATE24( UnityEngine.TrailRenderer target, float toStartWidth, float toEndWidth, float duration); + + delegate DG.Tweening.Core.TweenerCore __GEN_DELEGATE25( UnityEngine.TrailRenderer target, float endValue, float duration); + + static InternalGlobals() + { + extensionMethodMap = new Dictionary>() + { + + {typeof(UnityEngine.Audio.AudioMixer), new List(){ + + new __GEN_DELEGATE0(DG.Tweening.DOTweenModuleAudio.DOSetFloat) +#if UNITY_WSA && !UNITY_EDITOR + .GetMethodInfo(), +#else + .Method, +#endif + + new __GEN_DELEGATE1(DG.Tweening.DOTweenModuleAudio.DOComplete) +#if UNITY_WSA && !UNITY_EDITOR + .GetMethodInfo(), +#else + .Method, +#endif + + new __GEN_DELEGATE2(DG.Tweening.DOTweenModuleAudio.DOKill) +#if UNITY_WSA && !UNITY_EDITOR + .GetMethodInfo(), +#else + .Method, +#endif + + new __GEN_DELEGATE3(DG.Tweening.DOTweenModuleAudio.DOFlip) +#if UNITY_WSA && !UNITY_EDITOR + .GetMethodInfo(), +#else + .Method, +#endif + + new __GEN_DELEGATE4(DG.Tweening.DOTweenModuleAudio.DOGoto) +#if UNITY_WSA && !UNITY_EDITOR + .GetMethodInfo(), +#else + .Method, +#endif + + new __GEN_DELEGATE5(DG.Tweening.DOTweenModuleAudio.DOPause) +#if UNITY_WSA && !UNITY_EDITOR + .GetMethodInfo(), +#else + .Method, +#endif + + new __GEN_DELEGATE6(DG.Tweening.DOTweenModuleAudio.DOPlay) +#if UNITY_WSA && !UNITY_EDITOR + .GetMethodInfo(), +#else + .Method, +#endif + + new __GEN_DELEGATE7(DG.Tweening.DOTweenModuleAudio.DOPlayBackwards) +#if UNITY_WSA && !UNITY_EDITOR + .GetMethodInfo(), +#else + .Method, +#endif + + new __GEN_DELEGATE8(DG.Tweening.DOTweenModuleAudio.DOPlayForward) +#if UNITY_WSA && !UNITY_EDITOR + .GetMethodInfo(), +#else + .Method, +#endif + + new __GEN_DELEGATE9(DG.Tweening.DOTweenModuleAudio.DORestart) +#if UNITY_WSA && !UNITY_EDITOR + .GetMethodInfo(), +#else + .Method, +#endif + + new __GEN_DELEGATE10(DG.Tweening.DOTweenModuleAudio.DORewind) +#if UNITY_WSA && !UNITY_EDITOR + .GetMethodInfo(), +#else + .Method, +#endif + + new __GEN_DELEGATE11(DG.Tweening.DOTweenModuleAudio.DOSmoothRewind) +#if UNITY_WSA && !UNITY_EDITOR + .GetMethodInfo(), +#else + .Method, +#endif + + new __GEN_DELEGATE12(DG.Tweening.DOTweenModuleAudio.DOTogglePause) +#if UNITY_WSA && !UNITY_EDITOR + .GetMethodInfo(), +#else + .Method, +#endif + + }}, + + {typeof(UnityEngine.UI.Outline), new List(){ + + new __GEN_DELEGATE13(DG.Tweening.DOTweenModuleUI.DOColor) +#if UNITY_WSA && !UNITY_EDITOR + .GetMethodInfo(), +#else + .Method, +#endif + + new __GEN_DELEGATE14(DG.Tweening.DOTweenModuleUI.DOFade) +#if UNITY_WSA && !UNITY_EDITOR + .GetMethodInfo(), +#else + .Method, +#endif + + new __GEN_DELEGATE15(DG.Tweening.DOTweenModuleUI.DOScale) +#if UNITY_WSA && !UNITY_EDITOR + .GetMethodInfo(), +#else + .Method, +#endif + + }}, + + {typeof(com.adjust.sdk.AdjustEnvironment), new List(){ + + new __GEN_DELEGATE16(com.adjust.sdk.AdjustEnvironmentExtension.ToLowercaseString) +#if UNITY_WSA && !UNITY_EDITOR + .GetMethodInfo(), +#else + .Method, +#endif + + }}, + + {typeof(com.adjust.sdk.AdjustLogLevel), new List(){ + + new __GEN_DELEGATE17(com.adjust.sdk.AdjustLogLevelExtension.ToLowercaseString) +#if UNITY_WSA && !UNITY_EDITOR + .GetMethodInfo(), +#else + .Method, +#endif + + new __GEN_DELEGATE18(com.adjust.sdk.AdjustLogLevelExtension.ToUppercaseString) +#if UNITY_WSA && !UNITY_EDITOR + .GetMethodInfo(), +#else + .Method, +#endif + + }}, + + {typeof(com.adjust.sdk.AdjustUrlStrategy), new List(){ + + new __GEN_DELEGATE19(com.adjust.sdk.AdjustUrlStrategyExtension.ToLowerCaseString) +#if UNITY_WSA && !UNITY_EDITOR + .GetMethodInfo(), +#else + .Method, +#endif + + }}, + + {typeof(DG.Tweening.Core.TweenerCore), new List(){ + + new __GEN_DELEGATE20(DG.Tweening.TweenSettingsExtensions.SetOptions) +#if UNITY_WSA && !UNITY_EDITOR + .GetMethodInfo(), +#else + .Method, +#endif + + new __GEN_DELEGATE21(DG.Tweening.TweenSettingsExtensions.SetOptions) +#if UNITY_WSA && !UNITY_EDITOR + .GetMethodInfo(), +#else + .Method, +#endif + + }}, + + {typeof(DG.Tweening.Core.TweenerCore), new List(){ + + new __GEN_DELEGATE22(DG.Tweening.TweenSettingsExtensions.SetOptions) +#if UNITY_WSA && !UNITY_EDITOR + .GetMethodInfo(), +#else + .Method, +#endif + + }}, + + {typeof(DG.Tweening.Core.TweenerCore), new List(){ + + new __GEN_DELEGATE23(DG.Tweening.TweenSettingsExtensions.SetOptions) +#if UNITY_WSA && !UNITY_EDITOR + .GetMethodInfo(), +#else + .Method, +#endif + + }}, + + {typeof(UnityEngine.TrailRenderer), new List(){ + + new __GEN_DELEGATE24(DG.Tweening.ShortcutExtensions.DOResize) +#if UNITY_WSA && !UNITY_EDITOR + .GetMethodInfo(), +#else + .Method, +#endif + + new __GEN_DELEGATE25(DG.Tweening.ShortcutExtensions.DOTime) +#if UNITY_WSA && !UNITY_EDITOR + .GetMethodInfo(), +#else + .Method, +#endif + + }}, + + }; + + genTryArrayGetPtr = StaticLuaCallbacks.__tryArrayGet; + genTryArraySetPtr = StaticLuaCallbacks.__tryArraySet; + } + } +} diff --git a/Assets/XLua/Gen/com_adjust_sdk_AdjustAdRevenueWrap.cs b/Assets/XLua/Gen/com_adjust_sdk_AdjustAdRevenueWrap.cs new file mode 100644 index 000000000..da96ca618 --- /dev/null +++ b/Assets/XLua/Gen/com_adjust_sdk_AdjustAdRevenueWrap.cs @@ -0,0 +1,291 @@ +#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 comadjustsdkAdjustAdRevenueWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(com.adjust.sdk.AdjustAdRevenue); + Utils.BeginObjectRegister(type, L, translator, 0, 7, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setRevenue", _m_setRevenue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setAdImpressionsCount", _m_setAdImpressionsCount); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setAdRevenueNetwork", _m_setAdRevenueNetwork); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setAdRevenueUnit", _m_setAdRevenueUnit); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setAdRevenuePlacement", _m_setAdRevenuePlacement); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "addCallbackParameter", _m_addCallbackParameter); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "addPartnerParameter", _m_addPartnerParameter); + + + + + + 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) == 2 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _source = LuaAPI.lua_tostring(L, 2); + + var gen_ret = new com.adjust.sdk.AdjustAdRevenue(_source); + 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 com.adjust.sdk.AdjustAdRevenue constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setRevenue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustAdRevenue gen_to_be_invoked = (com.adjust.sdk.AdjustAdRevenue)translator.FastGetCSObj(L, 1); + + + + { + double _amount = LuaAPI.lua_tonumber(L, 2); + string _currency = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.setRevenue( _amount, _currency ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setAdImpressionsCount(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustAdRevenue gen_to_be_invoked = (com.adjust.sdk.AdjustAdRevenue)translator.FastGetCSObj(L, 1); + + + + { + int _adImpressionsCount = LuaAPI.xlua_tointeger(L, 2); + + gen_to_be_invoked.setAdImpressionsCount( _adImpressionsCount ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setAdRevenueNetwork(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustAdRevenue gen_to_be_invoked = (com.adjust.sdk.AdjustAdRevenue)translator.FastGetCSObj(L, 1); + + + + { + string _adRevenueNetwork = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.setAdRevenueNetwork( _adRevenueNetwork ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setAdRevenueUnit(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustAdRevenue gen_to_be_invoked = (com.adjust.sdk.AdjustAdRevenue)translator.FastGetCSObj(L, 1); + + + + { + string _adRevenueUnit = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.setAdRevenueUnit( _adRevenueUnit ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setAdRevenuePlacement(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustAdRevenue gen_to_be_invoked = (com.adjust.sdk.AdjustAdRevenue)translator.FastGetCSObj(L, 1); + + + + { + string _adRevenuePlacement = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.setAdRevenuePlacement( _adRevenuePlacement ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_addCallbackParameter(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustAdRevenue gen_to_be_invoked = (com.adjust.sdk.AdjustAdRevenue)translator.FastGetCSObj(L, 1); + + + + { + string _key = LuaAPI.lua_tostring(L, 2); + string _value = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.addCallbackParameter( _key, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_addPartnerParameter(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustAdRevenue gen_to_be_invoked = (com.adjust.sdk.AdjustAdRevenue)translator.FastGetCSObj(L, 1); + + + + { + string _key = LuaAPI.lua_tostring(L, 2); + string _value = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.addPartnerParameter( _key, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/com_adjust_sdk_AdjustAppStoreSubscriptionWrap.cs b/Assets/XLua/Gen/com_adjust_sdk_AdjustAppStoreSubscriptionWrap.cs new file mode 100644 index 000000000..f95e7c88b --- /dev/null +++ b/Assets/XLua/Gen/com_adjust_sdk_AdjustAppStoreSubscriptionWrap.cs @@ -0,0 +1,206 @@ +#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 comadjustsdkAdjustAppStoreSubscriptionWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(com.adjust.sdk.AdjustAppStoreSubscription); + Utils.BeginObjectRegister(type, L, translator, 0, 4, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setTransactionDate", _m_setTransactionDate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setSalesRegion", _m_setSalesRegion); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "addCallbackParameter", _m_addCallbackParameter); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "addPartnerParameter", _m_addPartnerParameter); + + + + + + 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) == 5 && (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) && (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING) && (LuaAPI.lua_isnil(L, 5) || LuaAPI.lua_type(L, 5) == LuaTypes.LUA_TSTRING)) + { + string _price = LuaAPI.lua_tostring(L, 2); + string _currency = LuaAPI.lua_tostring(L, 3); + string _transactionId = LuaAPI.lua_tostring(L, 4); + string _receipt = LuaAPI.lua_tostring(L, 5); + + var gen_ret = new com.adjust.sdk.AdjustAppStoreSubscription(_price, _currency, _transactionId, _receipt); + 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 com.adjust.sdk.AdjustAppStoreSubscription constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setTransactionDate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustAppStoreSubscription gen_to_be_invoked = (com.adjust.sdk.AdjustAppStoreSubscription)translator.FastGetCSObj(L, 1); + + + + { + string _transactionDate = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.setTransactionDate( _transactionDate ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setSalesRegion(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustAppStoreSubscription gen_to_be_invoked = (com.adjust.sdk.AdjustAppStoreSubscription)translator.FastGetCSObj(L, 1); + + + + { + string _salesRegion = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.setSalesRegion( _salesRegion ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_addCallbackParameter(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustAppStoreSubscription gen_to_be_invoked = (com.adjust.sdk.AdjustAppStoreSubscription)translator.FastGetCSObj(L, 1); + + + + { + string _key = LuaAPI.lua_tostring(L, 2); + string _value = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.addCallbackParameter( _key, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_addPartnerParameter(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustAppStoreSubscription gen_to_be_invoked = (com.adjust.sdk.AdjustAppStoreSubscription)translator.FastGetCSObj(L, 1); + + + + { + string _key = LuaAPI.lua_tostring(L, 2); + string _value = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.addPartnerParameter( _key, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/com_adjust_sdk_AdjustAttributionWrap.cs b/Assets/XLua/Gen/com_adjust_sdk_AdjustAttributionWrap.cs new file mode 100644 index 000000000..3982cd87a --- /dev/null +++ b/Assets/XLua/Gen/com_adjust_sdk_AdjustAttributionWrap.cs @@ -0,0 +1,475 @@ +#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 comadjustsdkAdjustAttributionWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(com.adjust.sdk.AdjustAttribution); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 12, 12); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "adid", _g_get_adid); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "network", _g_get_network); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "adgroup", _g_get_adgroup); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "campaign", _g_get_campaign); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "creative", _g_get_creative); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "clickLabel", _g_get_clickLabel); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "trackerName", _g_get_trackerName); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "trackerToken", _g_get_trackerToken); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "costType", _g_get_costType); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "costAmount", _g_get_costAmount); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "costCurrency", _g_get_costCurrency); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "fbInstallReferrer", _g_get_fbInstallReferrer); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "adid", _s_set_adid); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "network", _s_set_network); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "adgroup", _s_set_adgroup); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "campaign", _s_set_campaign); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "creative", _s_set_creative); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "clickLabel", _s_set_clickLabel); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "trackerName", _s_set_trackerName); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "trackerToken", _s_set_trackerToken); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "costType", _s_set_costType); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "costAmount", _s_set_costAmount); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "costCurrency", _s_set_costCurrency); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "fbInstallReferrer", _s_set_fbInstallReferrer); + + + 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 com.adjust.sdk.AdjustAttribution(); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _jsonString = LuaAPI.lua_tostring(L, 2); + + var gen_ret = new com.adjust.sdk.AdjustAttribution(_jsonString); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && translator.Assignable>(L, 2)) + { + System.Collections.Generic.Dictionary _dicAttributionData = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + + var gen_ret = new com.adjust.sdk.AdjustAttribution(_dicAttributionData); + 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 com.adjust.sdk.AdjustAttribution constructor!"); + + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_adid(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustAttribution gen_to_be_invoked = (com.adjust.sdk.AdjustAttribution)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.adid); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_network(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustAttribution gen_to_be_invoked = (com.adjust.sdk.AdjustAttribution)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.network); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_adgroup(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustAttribution gen_to_be_invoked = (com.adjust.sdk.AdjustAttribution)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.adgroup); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_campaign(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustAttribution gen_to_be_invoked = (com.adjust.sdk.AdjustAttribution)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.campaign); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_creative(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustAttribution gen_to_be_invoked = (com.adjust.sdk.AdjustAttribution)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.creative); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_clickLabel(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustAttribution gen_to_be_invoked = (com.adjust.sdk.AdjustAttribution)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.clickLabel); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_trackerName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustAttribution gen_to_be_invoked = (com.adjust.sdk.AdjustAttribution)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.trackerName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_trackerToken(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustAttribution gen_to_be_invoked = (com.adjust.sdk.AdjustAttribution)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.trackerToken); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_costType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustAttribution gen_to_be_invoked = (com.adjust.sdk.AdjustAttribution)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.costType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_costAmount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustAttribution gen_to_be_invoked = (com.adjust.sdk.AdjustAttribution)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.costAmount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_costCurrency(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustAttribution gen_to_be_invoked = (com.adjust.sdk.AdjustAttribution)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.costCurrency); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_fbInstallReferrer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustAttribution gen_to_be_invoked = (com.adjust.sdk.AdjustAttribution)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.fbInstallReferrer); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_adid(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustAttribution gen_to_be_invoked = (com.adjust.sdk.AdjustAttribution)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.adid = 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_network(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustAttribution gen_to_be_invoked = (com.adjust.sdk.AdjustAttribution)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.network = 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_adgroup(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustAttribution gen_to_be_invoked = (com.adjust.sdk.AdjustAttribution)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.adgroup = 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_campaign(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustAttribution gen_to_be_invoked = (com.adjust.sdk.AdjustAttribution)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.campaign = 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_creative(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustAttribution gen_to_be_invoked = (com.adjust.sdk.AdjustAttribution)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.creative = 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_clickLabel(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustAttribution gen_to_be_invoked = (com.adjust.sdk.AdjustAttribution)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.clickLabel = 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_trackerName(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustAttribution gen_to_be_invoked = (com.adjust.sdk.AdjustAttribution)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.trackerName = 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_trackerToken(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustAttribution gen_to_be_invoked = (com.adjust.sdk.AdjustAttribution)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.trackerToken = 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_costType(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustAttribution gen_to_be_invoked = (com.adjust.sdk.AdjustAttribution)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.costType = 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_costAmount(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustAttribution gen_to_be_invoked = (com.adjust.sdk.AdjustAttribution)translator.FastGetCSObj(L, 1); + System.Nullable gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.costAmount = 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_costCurrency(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustAttribution gen_to_be_invoked = (com.adjust.sdk.AdjustAttribution)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.costCurrency = 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_fbInstallReferrer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustAttribution gen_to_be_invoked = (com.adjust.sdk.AdjustAttribution)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.fbInstallReferrer = 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/com_adjust_sdk_AdjustConfigWrap.cs b/Assets/XLua/Gen/com_adjust_sdk_AdjustConfigWrap.cs new file mode 100644 index 000000000..2dd52cbe2 --- /dev/null +++ b/Assets/XLua/Gen/com_adjust_sdk_AdjustConfigWrap.cs @@ -0,0 +1,1365 @@ +#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 comadjustsdkAdjustConfigWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(com.adjust.sdk.AdjustConfig); + Utils.BeginObjectRegister(type, L, translator, 0, 39, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setLogLevel", _m_setLogLevel); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setDefaultTracker", _m_setDefaultTracker); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setExternalDeviceId", _m_setExternalDeviceId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setLaunchDeferredDeeplink", _m_setLaunchDeferredDeeplink); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setSendInBackground", _m_setSendInBackground); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setEventBufferingEnabled", _m_setEventBufferingEnabled); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setCoppaCompliantEnabled", _m_setCoppaCompliantEnabled); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setPlayStoreKidsAppEnabled", _m_setPlayStoreKidsAppEnabled); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setNeedsCost", _m_setNeedsCost); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setDelayStart", _m_setDelayStart); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setUserAgent", _m_setUserAgent); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setIsDeviceKnown", _m_setIsDeviceKnown); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setUrlStrategy", _m_setUrlStrategy); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "deactivateSKAdNetworkHandling", _m_deactivateSKAdNetworkHandling); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setLinkMeEnabled", _m_setLinkMeEnabled); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setDeferredDeeplinkDelegate", _m_setDeferredDeeplinkDelegate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "getDeferredDeeplinkDelegate", _m_getDeferredDeeplinkDelegate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setAttributionChangedDelegate", _m_setAttributionChangedDelegate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "getAttributionChangedDelegate", _m_getAttributionChangedDelegate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setEventSuccessDelegate", _m_setEventSuccessDelegate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "getEventSuccessDelegate", _m_getEventSuccessDelegate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setEventFailureDelegate", _m_setEventFailureDelegate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "getEventFailureDelegate", _m_getEventFailureDelegate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setSessionSuccessDelegate", _m_setSessionSuccessDelegate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "getSessionSuccessDelegate", _m_getSessionSuccessDelegate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setSessionFailureDelegate", _m_setSessionFailureDelegate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "getSessionFailureDelegate", _m_getSessionFailureDelegate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setConversionValueUpdatedDelegate", _m_setConversionValueUpdatedDelegate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setSkad4ConversionValueUpdatedDelegate", _m_setSkad4ConversionValueUpdatedDelegate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "getConversionValueUpdatedDelegate", _m_getConversionValueUpdatedDelegate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "getSkad4ConversionValueUpdatedDelegate", _m_getSkad4ConversionValueUpdatedDelegate); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setAppSecret", _m_setAppSecret); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setAllowiAdInfoReading", _m_setAllowiAdInfoReading); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setAllowAdServicesInfoReading", _m_setAllowAdServicesInfoReading); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setAllowIdfaReading", _m_setAllowIdfaReading); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setProcessName", _m_setProcessName); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setPreinstallTrackingEnabled", _m_setPreinstallTrackingEnabled); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setPreinstallFilePath", _m_setPreinstallFilePath); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setLogDelegate", _m_setLogDelegate); + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 15, 0, 0); + + + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AdjustUrlStrategyChina", com.adjust.sdk.AdjustConfig.AdjustUrlStrategyChina); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AdjustUrlStrategyIndia", com.adjust.sdk.AdjustConfig.AdjustUrlStrategyIndia); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AdjustUrlStrategyCn", com.adjust.sdk.AdjustConfig.AdjustUrlStrategyCn); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AdjustDataResidencyEU", com.adjust.sdk.AdjustConfig.AdjustDataResidencyEU); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AdjustDataResidencyTR", com.adjust.sdk.AdjustConfig.AdjustDataResidencyTR); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AdjustDataResidencyUS", com.adjust.sdk.AdjustConfig.AdjustDataResidencyUS); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AdjustAdRevenueSourceAppLovinMAX", com.adjust.sdk.AdjustConfig.AdjustAdRevenueSourceAppLovinMAX); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AdjustAdRevenueSourceMopub", com.adjust.sdk.AdjustConfig.AdjustAdRevenueSourceMopub); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AdjustAdRevenueSourceAdMob", com.adjust.sdk.AdjustConfig.AdjustAdRevenueSourceAdMob); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AdjustAdRevenueSourceIronSource", com.adjust.sdk.AdjustConfig.AdjustAdRevenueSourceIronSource); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AdjustAdRevenueSourceAdmost", com.adjust.sdk.AdjustConfig.AdjustAdRevenueSourceAdmost); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AdjustAdRevenueSourceUnity", com.adjust.sdk.AdjustConfig.AdjustAdRevenueSourceUnity); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AdjustAdRevenueSourceHeliumChartboost", com.adjust.sdk.AdjustConfig.AdjustAdRevenueSourceHeliumChartboost); + Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AdjustAdRevenueSourcePublisher", com.adjust.sdk.AdjustConfig.AdjustAdRevenueSourcePublisher); + + + + + 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) && translator.Assignable(L, 3)) + { + string _appToken = LuaAPI.lua_tostring(L, 2); + com.adjust.sdk.AdjustEnvironment _environment;translator.Get(L, 3, out _environment); + + var gen_ret = new com.adjust.sdk.AdjustConfig(_appToken, _environment); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 4 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING) && translator.Assignable(L, 3) && LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) + { + string _appToken = LuaAPI.lua_tostring(L, 2); + com.adjust.sdk.AdjustEnvironment _environment;translator.Get(L, 3, out _environment); + bool _allowSuppressLogLevel = LuaAPI.lua_toboolean(L, 4); + + var gen_ret = new com.adjust.sdk.AdjustConfig(_appToken, _environment, _allowSuppressLogLevel); + 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 com.adjust.sdk.AdjustConfig constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setLogLevel(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + com.adjust.sdk.AdjustLogLevel _logLevel;translator.Get(L, 2, out _logLevel); + + gen_to_be_invoked.setLogLevel( _logLevel ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setDefaultTracker(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + string _defaultTracker = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.setDefaultTracker( _defaultTracker ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setExternalDeviceId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + string _externalDeviceId = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.setExternalDeviceId( _externalDeviceId ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setLaunchDeferredDeeplink(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + bool _launchDeferredDeeplink = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.setLaunchDeferredDeeplink( _launchDeferredDeeplink ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setSendInBackground(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + bool _sendInBackground = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.setSendInBackground( _sendInBackground ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setEventBufferingEnabled(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + bool _eventBufferingEnabled = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.setEventBufferingEnabled( _eventBufferingEnabled ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setCoppaCompliantEnabled(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + bool _coppaCompliantEnabled = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.setCoppaCompliantEnabled( _coppaCompliantEnabled ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setPlayStoreKidsAppEnabled(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + bool _playStoreKidsAppEnabled = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.setPlayStoreKidsAppEnabled( _playStoreKidsAppEnabled ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setNeedsCost(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + bool _needsCost = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.setNeedsCost( _needsCost ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setDelayStart(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + double _delayStart = LuaAPI.lua_tonumber(L, 2); + + gen_to_be_invoked.setDelayStart( _delayStart ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setUserAgent(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + string _userAgent = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.setUserAgent( _userAgent ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setIsDeviceKnown(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + bool _isDeviceKnown = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.setIsDeviceKnown( _isDeviceKnown ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setUrlStrategy(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + string _urlStrategy = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.setUrlStrategy( _urlStrategy ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_deactivateSKAdNetworkHandling(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + + gen_to_be_invoked.deactivateSKAdNetworkHandling( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setLinkMeEnabled(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + bool _linkMeEnabled = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.setLinkMeEnabled( _linkMeEnabled ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setDeferredDeeplinkDelegate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable>(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + System.Action _deferredDeeplinkDelegate = translator.GetDelegate>(L, 2); + string _sceneName = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.setDeferredDeeplinkDelegate( _deferredDeeplinkDelegate, _sceneName ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Action _deferredDeeplinkDelegate = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.setDeferredDeeplinkDelegate( _deferredDeeplinkDelegate ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to com.adjust.sdk.AdjustConfig.setDeferredDeeplinkDelegate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_getDeferredDeeplinkDelegate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.getDeferredDeeplinkDelegate( ); + 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_setAttributionChangedDelegate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable>(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + System.Action _attributionChangedDelegate = translator.GetDelegate>(L, 2); + string _sceneName = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.setAttributionChangedDelegate( _attributionChangedDelegate, _sceneName ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Action _attributionChangedDelegate = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.setAttributionChangedDelegate( _attributionChangedDelegate ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to com.adjust.sdk.AdjustConfig.setAttributionChangedDelegate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_getAttributionChangedDelegate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.getAttributionChangedDelegate( ); + 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_setEventSuccessDelegate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable>(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + System.Action _eventSuccessDelegate = translator.GetDelegate>(L, 2); + string _sceneName = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.setEventSuccessDelegate( _eventSuccessDelegate, _sceneName ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Action _eventSuccessDelegate = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.setEventSuccessDelegate( _eventSuccessDelegate ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to com.adjust.sdk.AdjustConfig.setEventSuccessDelegate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_getEventSuccessDelegate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.getEventSuccessDelegate( ); + 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_setEventFailureDelegate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable>(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + System.Action _eventFailureDelegate = translator.GetDelegate>(L, 2); + string _sceneName = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.setEventFailureDelegate( _eventFailureDelegate, _sceneName ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Action _eventFailureDelegate = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.setEventFailureDelegate( _eventFailureDelegate ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to com.adjust.sdk.AdjustConfig.setEventFailureDelegate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_getEventFailureDelegate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.getEventFailureDelegate( ); + 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_setSessionSuccessDelegate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable>(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + System.Action _sessionSuccessDelegate = translator.GetDelegate>(L, 2); + string _sceneName = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.setSessionSuccessDelegate( _sessionSuccessDelegate, _sceneName ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Action _sessionSuccessDelegate = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.setSessionSuccessDelegate( _sessionSuccessDelegate ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to com.adjust.sdk.AdjustConfig.setSessionSuccessDelegate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_getSessionSuccessDelegate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.getSessionSuccessDelegate( ); + 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_setSessionFailureDelegate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable>(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + System.Action _sessionFailureDelegate = translator.GetDelegate>(L, 2); + string _sceneName = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.setSessionFailureDelegate( _sessionFailureDelegate, _sceneName ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Action _sessionFailureDelegate = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.setSessionFailureDelegate( _sessionFailureDelegate ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to com.adjust.sdk.AdjustConfig.setSessionFailureDelegate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_getSessionFailureDelegate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.getSessionFailureDelegate( ); + 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_setConversionValueUpdatedDelegate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable>(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + System.Action _conversionValueUpdatedDelegate = translator.GetDelegate>(L, 2); + string _sceneName = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.setConversionValueUpdatedDelegate( _conversionValueUpdatedDelegate, _sceneName ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Action _conversionValueUpdatedDelegate = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.setConversionValueUpdatedDelegate( _conversionValueUpdatedDelegate ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to com.adjust.sdk.AdjustConfig.setConversionValueUpdatedDelegate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setSkad4ConversionValueUpdatedDelegate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 3&& translator.Assignable>(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + System.Action _skad4ConversionValueUpdatedDelegate = translator.GetDelegate>(L, 2); + string _sceneName = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.setSkad4ConversionValueUpdatedDelegate( _skad4ConversionValueUpdatedDelegate, _sceneName ); + + + + return 0; + } + if(gen_param_count == 2&& translator.Assignable>(L, 2)) + { + System.Action _skad4ConversionValueUpdatedDelegate = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.setSkad4ConversionValueUpdatedDelegate( _skad4ConversionValueUpdatedDelegate ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to com.adjust.sdk.AdjustConfig.setSkad4ConversionValueUpdatedDelegate!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_getConversionValueUpdatedDelegate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.getConversionValueUpdatedDelegate( ); + 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_getSkad4ConversionValueUpdatedDelegate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.getSkad4ConversionValueUpdatedDelegate( ); + 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_setAppSecret(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + long _secretId = LuaAPI.lua_toint64(L, 2); + long _info1 = LuaAPI.lua_toint64(L, 3); + long _info2 = LuaAPI.lua_toint64(L, 4); + long _info3 = LuaAPI.lua_toint64(L, 5); + long _info4 = LuaAPI.lua_toint64(L, 6); + + gen_to_be_invoked.setAppSecret( _secretId, _info1, _info2, _info3, _info4 ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setAllowiAdInfoReading(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + bool _allowiAdInfoReading = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.setAllowiAdInfoReading( _allowiAdInfoReading ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setAllowAdServicesInfoReading(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + bool _allowAdServicesInfoReading = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.setAllowAdServicesInfoReading( _allowAdServicesInfoReading ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setAllowIdfaReading(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + bool _allowIdfaReading = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.setAllowIdfaReading( _allowIdfaReading ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setProcessName(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + string _processName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.setProcessName( _processName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setPreinstallTrackingEnabled(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + bool _preinstallTrackingEnabled = LuaAPI.lua_toboolean(L, 2); + + gen_to_be_invoked.setPreinstallTrackingEnabled( _preinstallTrackingEnabled ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setPreinstallFilePath(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + string _preinstallFilePath = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.setPreinstallFilePath( _preinstallFilePath ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setLogDelegate(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustConfig gen_to_be_invoked = (com.adjust.sdk.AdjustConfig)translator.FastGetCSObj(L, 1); + + + + { + System.Action _logDelegate = translator.GetDelegate>(L, 2); + + gen_to_be_invoked.setLogDelegate( _logDelegate ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/com_adjust_sdk_AdjustEnvironmentExtensionWrap.cs b/Assets/XLua/Gen/com_adjust_sdk_AdjustEnvironmentExtensionWrap.cs new file mode 100644 index 000000000..1f7088aba --- /dev/null +++ b/Assets/XLua/Gen/com_adjust_sdk_AdjustEnvironmentExtensionWrap.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 comadjustsdkAdjustEnvironmentExtensionWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(com.adjust.sdk.AdjustEnvironmentExtension); + 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, "com.adjust.sdk.AdjustEnvironmentExtension does not have a constructor!"); + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/com_adjust_sdk_AdjustEventFailureWrap.cs b/Assets/XLua/Gen/com_adjust_sdk_AdjustEventFailureWrap.cs new file mode 100644 index 000000000..9353fda26 --- /dev/null +++ b/Assets/XLua/Gen/com_adjust_sdk_AdjustEventFailureWrap.cs @@ -0,0 +1,377 @@ +#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 comadjustsdkAdjustEventFailureWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(com.adjust.sdk.AdjustEventFailure); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 7, 7); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "BuildJsonResponseFromString", _m_BuildJsonResponseFromString); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetJsonResponse", _m_GetJsonResponse); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Adid", _g_get_Adid); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Message", _g_get_Message); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Timestamp", _g_get_Timestamp); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "EventToken", _g_get_EventToken); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "CallbackId", _g_get_CallbackId); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "WillRetry", _g_get_WillRetry); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "JsonResponse", _g_get_JsonResponse); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Adid", _s_set_Adid); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Message", _s_set_Message); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Timestamp", _s_set_Timestamp); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "EventToken", _s_set_EventToken); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "CallbackId", _s_set_CallbackId); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "WillRetry", _s_set_WillRetry); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "JsonResponse", _s_set_JsonResponse); + + + 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 com.adjust.sdk.AdjustEventFailure(); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && translator.Assignable>(L, 2)) + { + System.Collections.Generic.Dictionary _eventFailureDataMap = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + + var gen_ret = new com.adjust.sdk.AdjustEventFailure(_eventFailureDataMap); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _jsonString = LuaAPI.lua_tostring(L, 2); + + var gen_ret = new com.adjust.sdk.AdjustEventFailure(_jsonString); + 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 com.adjust.sdk.AdjustEventFailure constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_BuildJsonResponseFromString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustEventFailure gen_to_be_invoked = (com.adjust.sdk.AdjustEventFailure)translator.FastGetCSObj(L, 1); + + + + { + string _jsonResponseString = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.BuildJsonResponseFromString( _jsonResponseString ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetJsonResponse(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustEventFailure gen_to_be_invoked = (com.adjust.sdk.AdjustEventFailure)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetJsonResponse( ); + 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_Adid(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustEventFailure gen_to_be_invoked = (com.adjust.sdk.AdjustEventFailure)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Adid); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Message(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustEventFailure gen_to_be_invoked = (com.adjust.sdk.AdjustEventFailure)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Message); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Timestamp(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustEventFailure gen_to_be_invoked = (com.adjust.sdk.AdjustEventFailure)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Timestamp); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_EventToken(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustEventFailure gen_to_be_invoked = (com.adjust.sdk.AdjustEventFailure)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.EventToken); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_CallbackId(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustEventFailure gen_to_be_invoked = (com.adjust.sdk.AdjustEventFailure)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.CallbackId); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_WillRetry(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustEventFailure gen_to_be_invoked = (com.adjust.sdk.AdjustEventFailure)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.WillRetry); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_JsonResponse(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustEventFailure gen_to_be_invoked = (com.adjust.sdk.AdjustEventFailure)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.JsonResponse); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Adid(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustEventFailure gen_to_be_invoked = (com.adjust.sdk.AdjustEventFailure)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Adid = 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_Message(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustEventFailure gen_to_be_invoked = (com.adjust.sdk.AdjustEventFailure)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Message = 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_Timestamp(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustEventFailure gen_to_be_invoked = (com.adjust.sdk.AdjustEventFailure)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Timestamp = 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_EventToken(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustEventFailure gen_to_be_invoked = (com.adjust.sdk.AdjustEventFailure)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.EventToken = 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_CallbackId(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustEventFailure gen_to_be_invoked = (com.adjust.sdk.AdjustEventFailure)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.CallbackId = 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_WillRetry(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustEventFailure gen_to_be_invoked = (com.adjust.sdk.AdjustEventFailure)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.WillRetry = 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_JsonResponse(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustEventFailure gen_to_be_invoked = (com.adjust.sdk.AdjustEventFailure)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.JsonResponse = (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/com_adjust_sdk_AdjustEventSuccessWrap.cs b/Assets/XLua/Gen/com_adjust_sdk_AdjustEventSuccessWrap.cs new file mode 100644 index 000000000..de3a7ee37 --- /dev/null +++ b/Assets/XLua/Gen/com_adjust_sdk_AdjustEventSuccessWrap.cs @@ -0,0 +1,346 @@ +#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 comadjustsdkAdjustEventSuccessWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(com.adjust.sdk.AdjustEventSuccess); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 6, 6); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "BuildJsonResponseFromString", _m_BuildJsonResponseFromString); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetJsonResponse", _m_GetJsonResponse); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Adid", _g_get_Adid); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Message", _g_get_Message); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Timestamp", _g_get_Timestamp); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "EventToken", _g_get_EventToken); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "CallbackId", _g_get_CallbackId); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "JsonResponse", _g_get_JsonResponse); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Adid", _s_set_Adid); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Message", _s_set_Message); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Timestamp", _s_set_Timestamp); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "EventToken", _s_set_EventToken); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "CallbackId", _s_set_CallbackId); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "JsonResponse", _s_set_JsonResponse); + + + 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 com.adjust.sdk.AdjustEventSuccess(); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && translator.Assignable>(L, 2)) + { + System.Collections.Generic.Dictionary _eventSuccessDataMap = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + + var gen_ret = new com.adjust.sdk.AdjustEventSuccess(_eventSuccessDataMap); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _jsonString = LuaAPI.lua_tostring(L, 2); + + var gen_ret = new com.adjust.sdk.AdjustEventSuccess(_jsonString); + 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 com.adjust.sdk.AdjustEventSuccess constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_BuildJsonResponseFromString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustEventSuccess gen_to_be_invoked = (com.adjust.sdk.AdjustEventSuccess)translator.FastGetCSObj(L, 1); + + + + { + string _jsonResponseString = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.BuildJsonResponseFromString( _jsonResponseString ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetJsonResponse(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustEventSuccess gen_to_be_invoked = (com.adjust.sdk.AdjustEventSuccess)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetJsonResponse( ); + 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_Adid(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustEventSuccess gen_to_be_invoked = (com.adjust.sdk.AdjustEventSuccess)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Adid); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Message(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustEventSuccess gen_to_be_invoked = (com.adjust.sdk.AdjustEventSuccess)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Message); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Timestamp(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustEventSuccess gen_to_be_invoked = (com.adjust.sdk.AdjustEventSuccess)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Timestamp); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_EventToken(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustEventSuccess gen_to_be_invoked = (com.adjust.sdk.AdjustEventSuccess)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.EventToken); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_CallbackId(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustEventSuccess gen_to_be_invoked = (com.adjust.sdk.AdjustEventSuccess)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.CallbackId); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_JsonResponse(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustEventSuccess gen_to_be_invoked = (com.adjust.sdk.AdjustEventSuccess)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.JsonResponse); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Adid(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustEventSuccess gen_to_be_invoked = (com.adjust.sdk.AdjustEventSuccess)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Adid = 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_Message(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustEventSuccess gen_to_be_invoked = (com.adjust.sdk.AdjustEventSuccess)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Message = 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_Timestamp(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustEventSuccess gen_to_be_invoked = (com.adjust.sdk.AdjustEventSuccess)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Timestamp = 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_EventToken(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustEventSuccess gen_to_be_invoked = (com.adjust.sdk.AdjustEventSuccess)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.EventToken = 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_CallbackId(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustEventSuccess gen_to_be_invoked = (com.adjust.sdk.AdjustEventSuccess)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.CallbackId = 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_JsonResponse(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustEventSuccess gen_to_be_invoked = (com.adjust.sdk.AdjustEventSuccess)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.JsonResponse = (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/com_adjust_sdk_AdjustEventWrap.cs b/Assets/XLua/Gen/com_adjust_sdk_AdjustEventWrap.cs new file mode 100644 index 000000000..90b85d1c8 --- /dev/null +++ b/Assets/XLua/Gen/com_adjust_sdk_AdjustEventWrap.cs @@ -0,0 +1,233 @@ +#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 comadjustsdkAdjustEventWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(com.adjust.sdk.AdjustEvent); + Utils.BeginObjectRegister(type, L, translator, 0, 5, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setRevenue", _m_setRevenue); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "addCallbackParameter", _m_addCallbackParameter); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "addPartnerParameter", _m_addPartnerParameter); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setTransactionId", _m_setTransactionId); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setCallbackId", _m_setCallbackId); + + + + + + 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) == 2 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _eventToken = LuaAPI.lua_tostring(L, 2); + + var gen_ret = new com.adjust.sdk.AdjustEvent(_eventToken); + 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 com.adjust.sdk.AdjustEvent constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setRevenue(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustEvent gen_to_be_invoked = (com.adjust.sdk.AdjustEvent)translator.FastGetCSObj(L, 1); + + + + { + double _amount = LuaAPI.lua_tonumber(L, 2); + string _currency = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.setRevenue( _amount, _currency ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_addCallbackParameter(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustEvent gen_to_be_invoked = (com.adjust.sdk.AdjustEvent)translator.FastGetCSObj(L, 1); + + + + { + string _key = LuaAPI.lua_tostring(L, 2); + string _value = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.addCallbackParameter( _key, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_addPartnerParameter(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustEvent gen_to_be_invoked = (com.adjust.sdk.AdjustEvent)translator.FastGetCSObj(L, 1); + + + + { + string _key = LuaAPI.lua_tostring(L, 2); + string _value = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.addPartnerParameter( _key, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setTransactionId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustEvent gen_to_be_invoked = (com.adjust.sdk.AdjustEvent)translator.FastGetCSObj(L, 1); + + + + { + string _transactionId = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.setTransactionId( _transactionId ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setCallbackId(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustEvent gen_to_be_invoked = (com.adjust.sdk.AdjustEvent)translator.FastGetCSObj(L, 1); + + + + { + string _callbackId = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.setCallbackId( _callbackId ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/com_adjust_sdk_AdjustLogLevelExtensionWrap.cs b/Assets/XLua/Gen/com_adjust_sdk_AdjustLogLevelExtensionWrap.cs new file mode 100644 index 000000000..404f7172d --- /dev/null +++ b/Assets/XLua/Gen/com_adjust_sdk_AdjustLogLevelExtensionWrap.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 comadjustsdkAdjustLogLevelExtensionWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(com.adjust.sdk.AdjustLogLevelExtension); + 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, "com.adjust.sdk.AdjustLogLevelExtension does not have a constructor!"); + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/com_adjust_sdk_AdjustPlayStoreSubscriptionWrap.cs b/Assets/XLua/Gen/com_adjust_sdk_AdjustPlayStoreSubscriptionWrap.cs new file mode 100644 index 000000000..6436b0975 --- /dev/null +++ b/Assets/XLua/Gen/com_adjust_sdk_AdjustPlayStoreSubscriptionWrap.cs @@ -0,0 +1,179 @@ +#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 comadjustsdkAdjustPlayStoreSubscriptionWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(com.adjust.sdk.AdjustPlayStoreSubscription); + Utils.BeginObjectRegister(type, L, translator, 0, 3, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "setPurchaseTime", _m_setPurchaseTime); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "addCallbackParameter", _m_addCallbackParameter); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "addPartnerParameter", _m_addPartnerParameter); + + + + + + 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) == 7 && (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) && (LuaAPI.lua_isnil(L, 4) || LuaAPI.lua_type(L, 4) == LuaTypes.LUA_TSTRING) && (LuaAPI.lua_isnil(L, 5) || LuaAPI.lua_type(L, 5) == LuaTypes.LUA_TSTRING) && (LuaAPI.lua_isnil(L, 6) || LuaAPI.lua_type(L, 6) == LuaTypes.LUA_TSTRING) && (LuaAPI.lua_isnil(L, 7) || LuaAPI.lua_type(L, 7) == LuaTypes.LUA_TSTRING)) + { + string _price = LuaAPI.lua_tostring(L, 2); + string _currency = LuaAPI.lua_tostring(L, 3); + string _sku = LuaAPI.lua_tostring(L, 4); + string _orderId = LuaAPI.lua_tostring(L, 5); + string _signature = LuaAPI.lua_tostring(L, 6); + string _purchaseToken = LuaAPI.lua_tostring(L, 7); + + var gen_ret = new com.adjust.sdk.AdjustPlayStoreSubscription(_price, _currency, _sku, _orderId, _signature, _purchaseToken); + 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 com.adjust.sdk.AdjustPlayStoreSubscription constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setPurchaseTime(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustPlayStoreSubscription gen_to_be_invoked = (com.adjust.sdk.AdjustPlayStoreSubscription)translator.FastGetCSObj(L, 1); + + + + { + string _purchaseTime = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.setPurchaseTime( _purchaseTime ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_addCallbackParameter(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustPlayStoreSubscription gen_to_be_invoked = (com.adjust.sdk.AdjustPlayStoreSubscription)translator.FastGetCSObj(L, 1); + + + + { + string _key = LuaAPI.lua_tostring(L, 2); + string _value = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.addCallbackParameter( _key, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_addPartnerParameter(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustPlayStoreSubscription gen_to_be_invoked = (com.adjust.sdk.AdjustPlayStoreSubscription)translator.FastGetCSObj(L, 1); + + + + { + string _key = LuaAPI.lua_tostring(L, 2); + string _value = LuaAPI.lua_tostring(L, 3); + + gen_to_be_invoked.addPartnerParameter( _key, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/com_adjust_sdk_AdjustSessionFailureWrap.cs b/Assets/XLua/Gen/com_adjust_sdk_AdjustSessionFailureWrap.cs new file mode 100644 index 000000000..b0ecb2629 --- /dev/null +++ b/Assets/XLua/Gen/com_adjust_sdk_AdjustSessionFailureWrap.cs @@ -0,0 +1,315 @@ +#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 comadjustsdkAdjustSessionFailureWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(com.adjust.sdk.AdjustSessionFailure); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 5, 5); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "BuildJsonResponseFromString", _m_BuildJsonResponseFromString); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetJsonResponse", _m_GetJsonResponse); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Adid", _g_get_Adid); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Message", _g_get_Message); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Timestamp", _g_get_Timestamp); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "WillRetry", _g_get_WillRetry); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "JsonResponse", _g_get_JsonResponse); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Adid", _s_set_Adid); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Message", _s_set_Message); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Timestamp", _s_set_Timestamp); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "WillRetry", _s_set_WillRetry); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "JsonResponse", _s_set_JsonResponse); + + + 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 com.adjust.sdk.AdjustSessionFailure(); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && translator.Assignable>(L, 2)) + { + System.Collections.Generic.Dictionary _sessionFailureDataMap = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + + var gen_ret = new com.adjust.sdk.AdjustSessionFailure(_sessionFailureDataMap); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _jsonString = LuaAPI.lua_tostring(L, 2); + + var gen_ret = new com.adjust.sdk.AdjustSessionFailure(_jsonString); + 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 com.adjust.sdk.AdjustSessionFailure constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_BuildJsonResponseFromString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustSessionFailure gen_to_be_invoked = (com.adjust.sdk.AdjustSessionFailure)translator.FastGetCSObj(L, 1); + + + + { + string _jsonResponseString = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.BuildJsonResponseFromString( _jsonResponseString ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetJsonResponse(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustSessionFailure gen_to_be_invoked = (com.adjust.sdk.AdjustSessionFailure)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetJsonResponse( ); + 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_Adid(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustSessionFailure gen_to_be_invoked = (com.adjust.sdk.AdjustSessionFailure)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Adid); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Message(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustSessionFailure gen_to_be_invoked = (com.adjust.sdk.AdjustSessionFailure)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Message); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Timestamp(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustSessionFailure gen_to_be_invoked = (com.adjust.sdk.AdjustSessionFailure)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Timestamp); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_WillRetry(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustSessionFailure gen_to_be_invoked = (com.adjust.sdk.AdjustSessionFailure)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.WillRetry); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_JsonResponse(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustSessionFailure gen_to_be_invoked = (com.adjust.sdk.AdjustSessionFailure)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.JsonResponse); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Adid(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustSessionFailure gen_to_be_invoked = (com.adjust.sdk.AdjustSessionFailure)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Adid = 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_Message(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustSessionFailure gen_to_be_invoked = (com.adjust.sdk.AdjustSessionFailure)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Message = 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_Timestamp(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustSessionFailure gen_to_be_invoked = (com.adjust.sdk.AdjustSessionFailure)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Timestamp = 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_WillRetry(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustSessionFailure gen_to_be_invoked = (com.adjust.sdk.AdjustSessionFailure)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.WillRetry = 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_JsonResponse(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustSessionFailure gen_to_be_invoked = (com.adjust.sdk.AdjustSessionFailure)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.JsonResponse = (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/com_adjust_sdk_AdjustSessionSuccessWrap.cs b/Assets/XLua/Gen/com_adjust_sdk_AdjustSessionSuccessWrap.cs new file mode 100644 index 000000000..4cb3ed3d4 --- /dev/null +++ b/Assets/XLua/Gen/com_adjust_sdk_AdjustSessionSuccessWrap.cs @@ -0,0 +1,284 @@ +#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 comadjustsdkAdjustSessionSuccessWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(com.adjust.sdk.AdjustSessionSuccess); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 4, 4); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "BuildJsonResponseFromString", _m_BuildJsonResponseFromString); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetJsonResponse", _m_GetJsonResponse); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Adid", _g_get_Adid); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Message", _g_get_Message); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Timestamp", _g_get_Timestamp); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "JsonResponse", _g_get_JsonResponse); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Adid", _s_set_Adid); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Message", _s_set_Message); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Timestamp", _s_set_Timestamp); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "JsonResponse", _s_set_JsonResponse); + + + 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 com.adjust.sdk.AdjustSessionSuccess(); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && translator.Assignable>(L, 2)) + { + System.Collections.Generic.Dictionary _sessionSuccessDataMap = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + + var gen_ret = new com.adjust.sdk.AdjustSessionSuccess(_sessionSuccessDataMap); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _jsonString = LuaAPI.lua_tostring(L, 2); + + var gen_ret = new com.adjust.sdk.AdjustSessionSuccess(_jsonString); + 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 com.adjust.sdk.AdjustSessionSuccess constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_BuildJsonResponseFromString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustSessionSuccess gen_to_be_invoked = (com.adjust.sdk.AdjustSessionSuccess)translator.FastGetCSObj(L, 1); + + + + { + string _jsonResponseString = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.BuildJsonResponseFromString( _jsonResponseString ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetJsonResponse(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustSessionSuccess gen_to_be_invoked = (com.adjust.sdk.AdjustSessionSuccess)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetJsonResponse( ); + 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_Adid(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustSessionSuccess gen_to_be_invoked = (com.adjust.sdk.AdjustSessionSuccess)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Adid); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Message(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustSessionSuccess gen_to_be_invoked = (com.adjust.sdk.AdjustSessionSuccess)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Message); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Timestamp(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustSessionSuccess gen_to_be_invoked = (com.adjust.sdk.AdjustSessionSuccess)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.Timestamp); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_JsonResponse(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustSessionSuccess gen_to_be_invoked = (com.adjust.sdk.AdjustSessionSuccess)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.JsonResponse); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_Adid(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustSessionSuccess gen_to_be_invoked = (com.adjust.sdk.AdjustSessionSuccess)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Adid = 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_Message(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustSessionSuccess gen_to_be_invoked = (com.adjust.sdk.AdjustSessionSuccess)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Message = 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_Timestamp(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustSessionSuccess gen_to_be_invoked = (com.adjust.sdk.AdjustSessionSuccess)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.Timestamp = 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_JsonResponse(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.AdjustSessionSuccess gen_to_be_invoked = (com.adjust.sdk.AdjustSessionSuccess)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.JsonResponse = (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/com_adjust_sdk_AdjustThirdPartySharingWrap.cs b/Assets/XLua/Gen/com_adjust_sdk_AdjustThirdPartySharingWrap.cs new file mode 100644 index 000000000..d665542b8 --- /dev/null +++ b/Assets/XLua/Gen/com_adjust_sdk_AdjustThirdPartySharingWrap.cs @@ -0,0 +1,147 @@ +#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 comadjustsdkAdjustThirdPartySharingWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(com.adjust.sdk.AdjustThirdPartySharing); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 0, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "addGranularOption", _m_addGranularOption); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "addPartnerSharingSetting", _m_addPartnerSharingSetting); + + + + + + 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) == 2 && translator.Assignable>(L, 2)) + { + System.Nullable _isEnabled;translator.Get(L, 2, out _isEnabled); + + var gen_ret = new com.adjust.sdk.AdjustThirdPartySharing(_isEnabled); + 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 com.adjust.sdk.AdjustThirdPartySharing constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_addGranularOption(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustThirdPartySharing gen_to_be_invoked = (com.adjust.sdk.AdjustThirdPartySharing)translator.FastGetCSObj(L, 1); + + + + { + string _partnerName = LuaAPI.lua_tostring(L, 2); + string _key = LuaAPI.lua_tostring(L, 3); + string _value = LuaAPI.lua_tostring(L, 4); + + gen_to_be_invoked.addGranularOption( _partnerName, _key, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_addPartnerSharingSetting(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.AdjustThirdPartySharing gen_to_be_invoked = (com.adjust.sdk.AdjustThirdPartySharing)translator.FastGetCSObj(L, 1); + + + + { + string _partnerName = LuaAPI.lua_tostring(L, 2); + string _key = LuaAPI.lua_tostring(L, 3); + bool _value = LuaAPI.lua_toboolean(L, 4); + + gen_to_be_invoked.addPartnerSharingSetting( _partnerName, _key, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/com_adjust_sdk_AdjustUrlStrategyExtensionWrap.cs b/Assets/XLua/Gen/com_adjust_sdk_AdjustUrlStrategyExtensionWrap.cs new file mode 100644 index 000000000..149850043 --- /dev/null +++ b/Assets/XLua/Gen/com_adjust_sdk_AdjustUrlStrategyExtensionWrap.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 comadjustsdkAdjustUrlStrategyExtensionWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(com.adjust.sdk.AdjustUrlStrategyExtension); + 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, "com.adjust.sdk.AdjustUrlStrategyExtension does not have a constructor!"); + } + + + + + + + + + + + + + + + + + + } +} diff --git a/Assets/XLua/Gen/com_adjust_sdk_AdjustUtilsWrap.cs b/Assets/XLua/Gen/com_adjust_sdk_AdjustUtilsWrap.cs new file mode 100644 index 000000000..0a27ea9b0 --- /dev/null +++ b/Assets/XLua/Gen/com_adjust_sdk_AdjustUtilsWrap.cs @@ -0,0 +1,1443 @@ +#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 comadjustsdkAdjustUtilsWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(com.adjust.sdk.AdjustUtils); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0); + + + + + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 14, 37, 37); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ConvertLogLevel", _m_ConvertLogLevel_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ConvertBool", _m_ConvertBool_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ConvertDouble", _m_ConvertDouble_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ConvertInt", _m_ConvertInt_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ConvertLong", _m_ConvertLong_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "ConvertListToJson", _m_ConvertListToJson_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetJsonResponseCompact", _m_GetJsonResponseCompact_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetJsonString", _m_GetJsonString_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "WriteJsonResponseDictionary", _m_WriteJsonResponseDictionary_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "TryGetValue", _m_TryGetValue_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetSkad4ConversionValue", _m_GetSkad4ConversionValue_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetSkad4CoarseValue", _m_GetSkad4CoarseValue_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "GetSkad4LockWindow", _m_GetSkad4LockWindow_xlua_st_); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyAdid", _g_get_KeyAdid); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyMessage", _g_get_KeyMessage); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyNetwork", _g_get_KeyNetwork); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyAdgroup", _g_get_KeyAdgroup); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyCampaign", _g_get_KeyCampaign); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyCreative", _g_get_KeyCreative); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyWillRetry", _g_get_KeyWillRetry); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTimestamp", _g_get_KeyTimestamp); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyCallbackId", _g_get_KeyCallbackId); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyEventToken", _g_get_KeyEventToken); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyClickLabel", _g_get_KeyClickLabel); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTrackerName", _g_get_KeyTrackerName); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTrackerToken", _g_get_KeyTrackerToken); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyJsonResponse", _g_get_KeyJsonResponse); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyCostType", _g_get_KeyCostType); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyCostAmount", _g_get_KeyCostAmount); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyCostCurrency", _g_get_KeyCostCurrency); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyFbInstallReferrer", _g_get_KeyFbInstallReferrer); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeySkadConversionValue", _g_get_KeySkadConversionValue); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeySkadCoarseValue", _g_get_KeySkadCoarseValue); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeySkadLockWindow", _g_get_KeySkadLockWindow); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsBaseUrl", _g_get_KeyTestOptionsBaseUrl); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsGdprUrl", _g_get_KeyTestOptionsGdprUrl); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsSubscriptionUrl", _g_get_KeyTestOptionsSubscriptionUrl); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsExtraPath", _g_get_KeyTestOptionsExtraPath); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsBasePath", _g_get_KeyTestOptionsBasePath); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsGdprPath", _g_get_KeyTestOptionsGdprPath); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsDeleteState", _g_get_KeyTestOptionsDeleteState); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsUseTestConnectionOptions", _g_get_KeyTestOptionsUseTestConnectionOptions); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsTimerIntervalInMilliseconds", _g_get_KeyTestOptionsTimerIntervalInMilliseconds); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsTimerStartInMilliseconds", _g_get_KeyTestOptionsTimerStartInMilliseconds); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsSessionIntervalInMilliseconds", _g_get_KeyTestOptionsSessionIntervalInMilliseconds); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsSubsessionIntervalInMilliseconds", _g_get_KeyTestOptionsSubsessionIntervalInMilliseconds); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsTeardown", _g_get_KeyTestOptionsTeardown); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsNoBackoffWait", _g_get_KeyTestOptionsNoBackoffWait); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsiAdFrameworkEnabled", _g_get_KeyTestOptionsiAdFrameworkEnabled); + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "KeyTestOptionsAdServicesFrameworkEnabled", _g_get_KeyTestOptionsAdServicesFrameworkEnabled); + + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyAdid", _s_set_KeyAdid); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyMessage", _s_set_KeyMessage); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyNetwork", _s_set_KeyNetwork); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyAdgroup", _s_set_KeyAdgroup); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyCampaign", _s_set_KeyCampaign); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyCreative", _s_set_KeyCreative); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyWillRetry", _s_set_KeyWillRetry); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTimestamp", _s_set_KeyTimestamp); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyCallbackId", _s_set_KeyCallbackId); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyEventToken", _s_set_KeyEventToken); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyClickLabel", _s_set_KeyClickLabel); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTrackerName", _s_set_KeyTrackerName); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTrackerToken", _s_set_KeyTrackerToken); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyJsonResponse", _s_set_KeyJsonResponse); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyCostType", _s_set_KeyCostType); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyCostAmount", _s_set_KeyCostAmount); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyCostCurrency", _s_set_KeyCostCurrency); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyFbInstallReferrer", _s_set_KeyFbInstallReferrer); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeySkadConversionValue", _s_set_KeySkadConversionValue); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeySkadCoarseValue", _s_set_KeySkadCoarseValue); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeySkadLockWindow", _s_set_KeySkadLockWindow); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsBaseUrl", _s_set_KeyTestOptionsBaseUrl); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsGdprUrl", _s_set_KeyTestOptionsGdprUrl); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsSubscriptionUrl", _s_set_KeyTestOptionsSubscriptionUrl); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsExtraPath", _s_set_KeyTestOptionsExtraPath); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsBasePath", _s_set_KeyTestOptionsBasePath); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsGdprPath", _s_set_KeyTestOptionsGdprPath); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsDeleteState", _s_set_KeyTestOptionsDeleteState); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsUseTestConnectionOptions", _s_set_KeyTestOptionsUseTestConnectionOptions); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsTimerIntervalInMilliseconds", _s_set_KeyTestOptionsTimerIntervalInMilliseconds); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsTimerStartInMilliseconds", _s_set_KeyTestOptionsTimerStartInMilliseconds); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsSessionIntervalInMilliseconds", _s_set_KeyTestOptionsSessionIntervalInMilliseconds); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsSubsessionIntervalInMilliseconds", _s_set_KeyTestOptionsSubsessionIntervalInMilliseconds); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsTeardown", _s_set_KeyTestOptionsTeardown); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsNoBackoffWait", _s_set_KeyTestOptionsNoBackoffWait); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsiAdFrameworkEnabled", _s_set_KeyTestOptionsiAdFrameworkEnabled); + Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "KeyTestOptionsAdServicesFrameworkEnabled", _s_set_KeyTestOptionsAdServicesFrameworkEnabled); + + + 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 com.adjust.sdk.AdjustUtils(); + 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 com.adjust.sdk.AdjustUtils constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ConvertLogLevel_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.Nullable _logLevel;translator.Get(L, 1, out _logLevel); + + var gen_ret = com.adjust.sdk.AdjustUtils.ConvertLogLevel( _logLevel ); + 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_ConvertBool_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.Nullable _value;translator.Get(L, 1, out _value); + + var gen_ret = com.adjust.sdk.AdjustUtils.ConvertBool( _value ); + 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_ConvertDouble_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.Nullable _value;translator.Get(L, 1, out _value); + + var gen_ret = com.adjust.sdk.AdjustUtils.ConvertDouble( _value ); + LuaAPI.lua_pushnumber(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_ConvertInt_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.Nullable _value;translator.Get(L, 1, out _value); + + var gen_ret = com.adjust.sdk.AdjustUtils.ConvertInt( _value ); + 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_ConvertLong_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.Nullable _value;translator.Get(L, 1, out _value); + + var gen_ret = com.adjust.sdk.AdjustUtils.ConvertLong( _value ); + LuaAPI.lua_pushint64(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_ConvertListToJson_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.Collections.Generic.List _list = (System.Collections.Generic.List)translator.GetObject(L, 1, typeof(System.Collections.Generic.List)); + + var gen_ret = com.adjust.sdk.AdjustUtils.ConvertListToJson( _list ); + 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 _m_GetJsonResponseCompact_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.Collections.Generic.Dictionary _dictionary = (System.Collections.Generic.Dictionary)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary)); + + var gen_ret = com.adjust.sdk.AdjustUtils.GetJsonResponseCompact( _dictionary ); + 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 _m_GetJsonString_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + com.adjust.sdk.JSONNode _node = (com.adjust.sdk.JSONNode)translator.GetObject(L, 1, typeof(com.adjust.sdk.JSONNode)); + string _key = LuaAPI.lua_tostring(L, 2); + + var gen_ret = com.adjust.sdk.AdjustUtils.GetJsonString( _node, _key ); + 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 _m_WriteJsonResponseDictionary_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + com.adjust.sdk.JSONClass _jsonObject = (com.adjust.sdk.JSONClass)translator.GetObject(L, 1, typeof(com.adjust.sdk.JSONClass)); + System.Collections.Generic.Dictionary _output = (System.Collections.Generic.Dictionary)translator.GetObject(L, 2, typeof(System.Collections.Generic.Dictionary)); + + com.adjust.sdk.AdjustUtils.WriteJsonResponseDictionary( _jsonObject, _output ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_TryGetValue_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.Collections.Generic.Dictionary _dictionary = (System.Collections.Generic.Dictionary)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary)); + string _key = LuaAPI.lua_tostring(L, 2); + + var gen_ret = com.adjust.sdk.AdjustUtils.TryGetValue( _dictionary, _key ); + 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 _m_GetSkad4ConversionValue_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _conversionValueUpdate = LuaAPI.lua_tostring(L, 1); + + var gen_ret = com.adjust.sdk.AdjustUtils.GetSkad4ConversionValue( _conversionValueUpdate ); + 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_GetSkad4CoarseValue_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _conversionValueUpdate = LuaAPI.lua_tostring(L, 1); + + var gen_ret = com.adjust.sdk.AdjustUtils.GetSkad4CoarseValue( _conversionValueUpdate ); + 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 _m_GetSkad4LockWindow_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _conversionValueUpdate = LuaAPI.lua_tostring(L, 1); + + var gen_ret = com.adjust.sdk.AdjustUtils.GetSkad4LockWindow( _conversionValueUpdate ); + 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 _g_get_KeyAdid(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyAdid); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyMessage(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyMessage); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyNetwork(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyNetwork); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyAdgroup(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyAdgroup); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyCampaign(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyCampaign); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyCreative(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyCreative); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyWillRetry(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyWillRetry); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyTimestamp(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTimestamp); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyCallbackId(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyCallbackId); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyEventToken(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyEventToken); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyClickLabel(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyClickLabel); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyTrackerName(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTrackerName); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyTrackerToken(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTrackerToken); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyJsonResponse(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyJsonResponse); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyCostType(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyCostType); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyCostAmount(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyCostAmount); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyCostCurrency(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyCostCurrency); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyFbInstallReferrer(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyFbInstallReferrer); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeySkadConversionValue(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeySkadConversionValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeySkadCoarseValue(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeySkadCoarseValue); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeySkadLockWindow(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeySkadLockWindow); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyTestOptionsBaseUrl(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsBaseUrl); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyTestOptionsGdprUrl(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsGdprUrl); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyTestOptionsSubscriptionUrl(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsSubscriptionUrl); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyTestOptionsExtraPath(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsExtraPath); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyTestOptionsBasePath(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsBasePath); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyTestOptionsGdprPath(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsGdprPath); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyTestOptionsDeleteState(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsDeleteState); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyTestOptionsUseTestConnectionOptions(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsUseTestConnectionOptions); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyTestOptionsTimerIntervalInMilliseconds(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsTimerIntervalInMilliseconds); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyTestOptionsTimerStartInMilliseconds(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsTimerStartInMilliseconds); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyTestOptionsSessionIntervalInMilliseconds(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsSessionIntervalInMilliseconds); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyTestOptionsSubsessionIntervalInMilliseconds(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsSubsessionIntervalInMilliseconds); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyTestOptionsTeardown(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsTeardown); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyTestOptionsNoBackoffWait(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsNoBackoffWait); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyTestOptionsiAdFrameworkEnabled(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsiAdFrameworkEnabled); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_KeyTestOptionsAdServicesFrameworkEnabled(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, com.adjust.sdk.AdjustUtils.KeyTestOptionsAdServicesFrameworkEnabled); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyAdid(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyAdid = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyMessage(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyMessage = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyNetwork(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyNetwork = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyAdgroup(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyAdgroup = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyCampaign(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyCampaign = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyCreative(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyCreative = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyWillRetry(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyWillRetry = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyTimestamp(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyTimestamp = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyCallbackId(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyCallbackId = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyEventToken(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyEventToken = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyClickLabel(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyClickLabel = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyTrackerName(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyTrackerName = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyTrackerToken(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyTrackerToken = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyJsonResponse(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyJsonResponse = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyCostType(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyCostType = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyCostAmount(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyCostAmount = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyCostCurrency(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyCostCurrency = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyFbInstallReferrer(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyFbInstallReferrer = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeySkadConversionValue(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeySkadConversionValue = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeySkadCoarseValue(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeySkadCoarseValue = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeySkadLockWindow(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeySkadLockWindow = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyTestOptionsBaseUrl(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyTestOptionsBaseUrl = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyTestOptionsGdprUrl(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyTestOptionsGdprUrl = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyTestOptionsSubscriptionUrl(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyTestOptionsSubscriptionUrl = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyTestOptionsExtraPath(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyTestOptionsExtraPath = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyTestOptionsBasePath(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyTestOptionsBasePath = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyTestOptionsGdprPath(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyTestOptionsGdprPath = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyTestOptionsDeleteState(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyTestOptionsDeleteState = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyTestOptionsUseTestConnectionOptions(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyTestOptionsUseTestConnectionOptions = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyTestOptionsTimerIntervalInMilliseconds(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyTestOptionsTimerIntervalInMilliseconds = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyTestOptionsTimerStartInMilliseconds(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyTestOptionsTimerStartInMilliseconds = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyTestOptionsSessionIntervalInMilliseconds(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyTestOptionsSessionIntervalInMilliseconds = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyTestOptionsSubsessionIntervalInMilliseconds(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyTestOptionsSubsessionIntervalInMilliseconds = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyTestOptionsTeardown(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyTestOptionsTeardown = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyTestOptionsNoBackoffWait(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyTestOptionsNoBackoffWait = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyTestOptionsiAdFrameworkEnabled(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyTestOptionsiAdFrameworkEnabled = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_KeyTestOptionsAdServicesFrameworkEnabled(RealStatePtr L) + { + try { + + com.adjust.sdk.AdjustUtils.KeyTestOptionsAdServicesFrameworkEnabled = LuaAPI.lua_tostring(L, 1); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/com_adjust_sdk_AdjustWrap.cs b/Assets/XLua/Gen/com_adjust_sdk_AdjustWrap.cs new file mode 100644 index 000000000..bdb7e92dd --- /dev/null +++ b/Assets/XLua/Gen/com_adjust_sdk_AdjustWrap.cs @@ -0,0 +1,1845 @@ +#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 comadjustsdkAdjustWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(com.adjust.sdk.Adjust); + Utils.BeginObjectRegister(type, L, translator, 0, 0, 26, 26); + + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startManually", _g_get_startManually); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "androidAppToken", _g_get_androidAppToken); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "iosAppToken", _g_get_iosAppToken); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "environment", _g_get_environment); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "logLevel", _g_get_logLevel); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "eventBuffering", _g_get_eventBuffering); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "sendInBackground", _g_get_sendInBackground); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "launchDeferredDeeplink", _g_get_launchDeferredDeeplink); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "needsCost", _g_get_needsCost); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "coppaCompliant", _g_get_coppaCompliant); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "linkMe", _g_get_linkMe); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "defaultTracker", _g_get_defaultTracker); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "urlStrategy", _g_get_urlStrategy); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "startDelay", _g_get_startDelay); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "secretId", _g_get_secretId); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "info1", _g_get_info1); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "info2", _g_get_info2); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "info3", _g_get_info3); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "info4", _g_get_info4); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preinstallTracking", _g_get_preinstallTracking); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "preinstallFilePath", _g_get_preinstallFilePath); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "playStoreKidsApp", _g_get_playStoreKidsApp); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "iadInfoReading", _g_get_iadInfoReading); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "adServicesInfoReading", _g_get_adServicesInfoReading); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "idfaInfoReading", _g_get_idfaInfoReading); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "skAdNetworkHandling", _g_get_skAdNetworkHandling); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startManually", _s_set_startManually); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "androidAppToken", _s_set_androidAppToken); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "iosAppToken", _s_set_iosAppToken); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "environment", _s_set_environment); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "logLevel", _s_set_logLevel); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "eventBuffering", _s_set_eventBuffering); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "sendInBackground", _s_set_sendInBackground); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "launchDeferredDeeplink", _s_set_launchDeferredDeeplink); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "needsCost", _s_set_needsCost); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "coppaCompliant", _s_set_coppaCompliant); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "linkMe", _s_set_linkMe); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "defaultTracker", _s_set_defaultTracker); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "urlStrategy", _s_set_urlStrategy); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "startDelay", _s_set_startDelay); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "secretId", _s_set_secretId); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "info1", _s_set_info1); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "info2", _s_set_info2); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "info3", _s_set_info3); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "info4", _s_set_info4); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "preinstallTracking", _s_set_preinstallTracking); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "preinstallFilePath", _s_set_preinstallFilePath); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "playStoreKidsApp", _s_set_playStoreKidsApp); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "iadInfoReading", _s_set_iadInfoReading); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "adServicesInfoReading", _s_set_adServicesInfoReading); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "idfaInfoReading", _s_set_idfaInfoReading); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "skAdNetworkHandling", _s_set_skAdNetworkHandling); + + + Utils.EndObjectRegister(type, L, translator, null, null, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 35, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "start", _m_start_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "trackEvent", _m_trackEvent_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "setEnabled", _m_setEnabled_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "isEnabled", _m_isEnabled_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "setOfflineMode", _m_setOfflineMode_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "setDeviceToken", _m_setDeviceToken_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "gdprForgetMe", _m_gdprForgetMe_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "disableThirdPartySharing", _m_disableThirdPartySharing_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "appWillOpenUrl", _m_appWillOpenUrl_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "sendFirstPackages", _m_sendFirstPackages_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "addSessionPartnerParameter", _m_addSessionPartnerParameter_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "addSessionCallbackParameter", _m_addSessionCallbackParameter_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "removeSessionPartnerParameter", _m_removeSessionPartnerParameter_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "removeSessionCallbackParameter", _m_removeSessionCallbackParameter_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "resetSessionPartnerParameters", _m_resetSessionPartnerParameters_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "resetSessionCallbackParameters", _m_resetSessionCallbackParameters_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "trackAdRevenue", _m_trackAdRevenue_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "trackAppStoreSubscription", _m_trackAppStoreSubscription_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "trackPlayStoreSubscription", _m_trackPlayStoreSubscription_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "trackThirdPartySharing", _m_trackThirdPartySharing_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "trackMeasurementConsent", _m_trackMeasurementConsent_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "requestTrackingAuthorizationWithCompletionHandler", _m_requestTrackingAuthorizationWithCompletionHandler_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "updateConversionValue", _m_updateConversionValue_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "checkForNewAttStatus", _m_checkForNewAttStatus_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "getAppTrackingAuthorizationStatus", _m_getAppTrackingAuthorizationStatus_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "getAdid", _m_getAdid_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "getAttribution", _m_getAttribution_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "getWinAdid", _m_getWinAdid_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "getIdfa", _m_getIdfa_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "getSdkVersion", _m_getSdkVersion_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "getGoogleAdId", _m_getGoogleAdId_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "getAmazonAdId", _m_getAmazonAdId_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "getLastDeeplink", _m_getLastDeeplink_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "SetTestOptions", _m_SetTestOptions_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 com.adjust.sdk.Adjust(); + 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 com.adjust.sdk.Adjust constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_start_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + com.adjust.sdk.AdjustConfig _adjustConfig = (com.adjust.sdk.AdjustConfig)translator.GetObject(L, 1, typeof(com.adjust.sdk.AdjustConfig)); + + com.adjust.sdk.Adjust.start( _adjustConfig ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_trackEvent_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + com.adjust.sdk.AdjustEvent _adjustEvent = (com.adjust.sdk.AdjustEvent)translator.GetObject(L, 1, typeof(com.adjust.sdk.AdjustEvent)); + + com.adjust.sdk.Adjust.trackEvent( _adjustEvent ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setEnabled_xlua_st_(RealStatePtr L) + { + try { + + + + + { + bool _enabled = LuaAPI.lua_toboolean(L, 1); + + com.adjust.sdk.Adjust.setEnabled( _enabled ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_isEnabled_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = com.adjust.sdk.Adjust.isEnabled( ); + 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_setOfflineMode_xlua_st_(RealStatePtr L) + { + try { + + + + + { + bool _enabled = LuaAPI.lua_toboolean(L, 1); + + com.adjust.sdk.Adjust.setOfflineMode( _enabled ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_setDeviceToken_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _deviceToken = LuaAPI.lua_tostring(L, 1); + + com.adjust.sdk.Adjust.setDeviceToken( _deviceToken ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_gdprForgetMe_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + com.adjust.sdk.Adjust.gdprForgetMe( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_disableThirdPartySharing_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + com.adjust.sdk.Adjust.disableThirdPartySharing( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_appWillOpenUrl_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _url = LuaAPI.lua_tostring(L, 1); + + com.adjust.sdk.Adjust.appWillOpenUrl( _url ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_sendFirstPackages_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + com.adjust.sdk.Adjust.sendFirstPackages( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_addSessionPartnerParameter_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _key = LuaAPI.lua_tostring(L, 1); + string _value = LuaAPI.lua_tostring(L, 2); + + com.adjust.sdk.Adjust.addSessionPartnerParameter( _key, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_addSessionCallbackParameter_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _key = LuaAPI.lua_tostring(L, 1); + string _value = LuaAPI.lua_tostring(L, 2); + + com.adjust.sdk.Adjust.addSessionCallbackParameter( _key, _value ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_removeSessionPartnerParameter_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _key = LuaAPI.lua_tostring(L, 1); + + com.adjust.sdk.Adjust.removeSessionPartnerParameter( _key ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_removeSessionCallbackParameter_xlua_st_(RealStatePtr L) + { + try { + + + + + { + string _key = LuaAPI.lua_tostring(L, 1); + + com.adjust.sdk.Adjust.removeSessionCallbackParameter( _key ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_resetSessionPartnerParameters_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + com.adjust.sdk.Adjust.resetSessionPartnerParameters( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_resetSessionCallbackParameters_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + com.adjust.sdk.Adjust.resetSessionCallbackParameters( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_trackAdRevenue_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& translator.Assignable(L, 1)) + { + com.adjust.sdk.AdjustAdRevenue _adRevenue = (com.adjust.sdk.AdjustAdRevenue)translator.GetObject(L, 1, typeof(com.adjust.sdk.AdjustAdRevenue)); + + com.adjust.sdk.Adjust.trackAdRevenue( _adRevenue ); + + + + return 0; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _source = LuaAPI.lua_tostring(L, 1); + string _payload = LuaAPI.lua_tostring(L, 2); + + com.adjust.sdk.Adjust.trackAdRevenue( _source, _payload ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to com.adjust.sdk.Adjust.trackAdRevenue!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_trackAppStoreSubscription_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + com.adjust.sdk.AdjustAppStoreSubscription _subscription = (com.adjust.sdk.AdjustAppStoreSubscription)translator.GetObject(L, 1, typeof(com.adjust.sdk.AdjustAppStoreSubscription)); + + com.adjust.sdk.Adjust.trackAppStoreSubscription( _subscription ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_trackPlayStoreSubscription_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + com.adjust.sdk.AdjustPlayStoreSubscription _subscription = (com.adjust.sdk.AdjustPlayStoreSubscription)translator.GetObject(L, 1, typeof(com.adjust.sdk.AdjustPlayStoreSubscription)); + + com.adjust.sdk.Adjust.trackPlayStoreSubscription( _subscription ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_trackThirdPartySharing_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + com.adjust.sdk.AdjustThirdPartySharing _thirdPartySharing = (com.adjust.sdk.AdjustThirdPartySharing)translator.GetObject(L, 1, typeof(com.adjust.sdk.AdjustThirdPartySharing)); + + com.adjust.sdk.Adjust.trackThirdPartySharing( _thirdPartySharing ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_trackMeasurementConsent_xlua_st_(RealStatePtr L) + { + try { + + + + + { + bool _measurementConsent = LuaAPI.lua_toboolean(L, 1); + + com.adjust.sdk.Adjust.trackMeasurementConsent( _measurementConsent ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_requestTrackingAuthorizationWithCompletionHandler_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable>(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + System.Action _statusCallback = translator.GetDelegate>(L, 1); + string _sceneName = LuaAPI.lua_tostring(L, 2); + + com.adjust.sdk.Adjust.requestTrackingAuthorizationWithCompletionHandler( _statusCallback, _sceneName ); + + + + return 0; + } + if(gen_param_count == 1&& translator.Assignable>(L, 1)) + { + System.Action _statusCallback = translator.GetDelegate>(L, 1); + + com.adjust.sdk.Adjust.requestTrackingAuthorizationWithCompletionHandler( _statusCallback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to com.adjust.sdk.Adjust.requestTrackingAuthorizationWithCompletionHandler!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_updateConversionValue_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) + { + int _conversionValue = LuaAPI.xlua_tointeger(L, 1); + + com.adjust.sdk.Adjust.updateConversionValue( _conversionValue ); + + + + return 0; + } + if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable>(L, 2)&& (LuaAPI.lua_isnil(L, 3) || LuaAPI.lua_type(L, 3) == LuaTypes.LUA_TSTRING)) + { + int _conversionValue = LuaAPI.xlua_tointeger(L, 1); + System.Action _completionCallback = translator.GetDelegate>(L, 2); + string _sceneName = LuaAPI.lua_tostring(L, 3); + + com.adjust.sdk.Adjust.updateConversionValue( _conversionValue, _completionCallback, _sceneName ); + + + + return 0; + } + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable>(L, 2)) + { + int _conversionValue = LuaAPI.xlua_tointeger(L, 1); + System.Action _completionCallback = translator.GetDelegate>(L, 2); + + com.adjust.sdk.Adjust.updateConversionValue( _conversionValue, _completionCallback ); + + + + return 0; + } + if(gen_param_count == 5&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)&& translator.Assignable>(L, 4)&& (LuaAPI.lua_isnil(L, 5) || LuaAPI.lua_type(L, 5) == LuaTypes.LUA_TSTRING)) + { + int _conversionValue = LuaAPI.xlua_tointeger(L, 1); + string _coarseValue = LuaAPI.lua_tostring(L, 2); + bool _lockWindow = LuaAPI.lua_toboolean(L, 3); + System.Action _completionCallback = translator.GetDelegate>(L, 4); + string _sceneName = LuaAPI.lua_tostring(L, 5); + + com.adjust.sdk.Adjust.updateConversionValue( _conversionValue, _coarseValue, _lockWindow, _completionCallback, _sceneName ); + + + + return 0; + } + if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3)&& translator.Assignable>(L, 4)) + { + int _conversionValue = LuaAPI.xlua_tointeger(L, 1); + string _coarseValue = LuaAPI.lua_tostring(L, 2); + bool _lockWindow = LuaAPI.lua_toboolean(L, 3); + System.Action _completionCallback = translator.GetDelegate>(L, 4); + + com.adjust.sdk.Adjust.updateConversionValue( _conversionValue, _coarseValue, _lockWindow, _completionCallback ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to com.adjust.sdk.Adjust.updateConversionValue!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_checkForNewAttStatus_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + com.adjust.sdk.Adjust.checkForNewAttStatus( ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_getAppTrackingAuthorizationStatus_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = com.adjust.sdk.Adjust.getAppTrackingAuthorizationStatus( ); + 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_getAdid_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = com.adjust.sdk.Adjust.getAdid( ); + 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 _m_getAttribution_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + + var gen_ret = com.adjust.sdk.Adjust.getAttribution( ); + 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_getWinAdid_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = com.adjust.sdk.Adjust.getWinAdid( ); + 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 _m_getIdfa_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = com.adjust.sdk.Adjust.getIdfa( ); + 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 _m_getSdkVersion_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = com.adjust.sdk.Adjust.getSdkVersion( ); + 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 _m_getGoogleAdId_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.Action _onDeviceIdsRead = translator.GetDelegate>(L, 1); + + com.adjust.sdk.Adjust.getGoogleAdId( _onDeviceIdsRead ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_getAmazonAdId_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = com.adjust.sdk.Adjust.getAmazonAdId( ); + 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 _m_getLastDeeplink_xlua_st_(RealStatePtr L) + { + try { + + + + + { + + var gen_ret = com.adjust.sdk.Adjust.getLastDeeplink( ); + 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 _m_SetTestOptions_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.Collections.Generic.Dictionary _testOptions = (System.Collections.Generic.Dictionary)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary)); + + com.adjust.sdk.Adjust.SetTestOptions( _testOptions ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startManually(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.startManually); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_androidAppToken(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.androidAppToken); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_iosAppToken(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.iosAppToken); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_environment(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.environment); + } 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); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + translator.Push(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_eventBuffering(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.eventBuffering); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_sendInBackground(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.sendInBackground); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_launchDeferredDeeplink(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.launchDeferredDeeplink); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_needsCost(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.needsCost); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_coppaCompliant(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.coppaCompliant); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_linkMe(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.linkMe); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_defaultTracker(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.defaultTracker); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_urlStrategy(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.urlStrategy); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_startDelay(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.startDelay); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_secretId(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushint64(L, gen_to_be_invoked.secretId); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_info1(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushint64(L, gen_to_be_invoked.info1); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_info2(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushint64(L, gen_to_be_invoked.info2); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_info3(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushint64(L, gen_to_be_invoked.info3); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_info4(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushint64(L, gen_to_be_invoked.info4); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preinstallTracking(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.preinstallTracking); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_preinstallFilePath(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushstring(L, gen_to_be_invoked.preinstallFilePath); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_playStoreKidsApp(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.playStoreKidsApp); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_iadInfoReading(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.iadInfoReading); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_adServicesInfoReading(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.adServicesInfoReading); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_idfaInfoReading(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.idfaInfoReading); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_skAdNetworkHandling(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.skAdNetworkHandling); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _s_set_startManually(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.startManually = 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_androidAppToken(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.androidAppToken = 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_iosAppToken(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.iosAppToken = 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_environment(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + com.adjust.sdk.AdjustEnvironment gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.environment = 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_logLevel(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + com.adjust.sdk.AdjustLogLevel 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_eventBuffering(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.eventBuffering = 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_sendInBackground(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.sendInBackground = 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_launchDeferredDeeplink(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.launchDeferredDeeplink = 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_needsCost(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.needsCost = 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_coppaCompliant(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.coppaCompliant = 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_linkMe(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.linkMe = 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_defaultTracker(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.defaultTracker = 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_urlStrategy(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + com.adjust.sdk.AdjustUrlStrategy gen_value;translator.Get(L, 2, out gen_value); + gen_to_be_invoked.urlStrategy = 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_startDelay(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.startDelay = 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_secretId(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.secretId = 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_info1(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.info1 = 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_info2(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.info2 = 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_info3(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.info3 = 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_info4(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.info4 = 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_preinstallTracking(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.preinstallTracking = 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_preinstallFilePath(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.preinstallFilePath = 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_playStoreKidsApp(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.playStoreKidsApp = 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_iadInfoReading(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.iadInfoReading = 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_adServicesInfoReading(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.adServicesInfoReading = 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_idfaInfoReading(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.idfaInfoReading = 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_skAdNetworkHandling(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.Adjust gen_to_be_invoked = (com.adjust.sdk.Adjust)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.skAdNetworkHandling = LuaAPI.lua_toboolean(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/com_adjust_sdk_JSONArrayWrap.cs b/Assets/XLua/Gen/com_adjust_sdk_JSONArrayWrap.cs new file mode 100644 index 000000000..0418f3a38 --- /dev/null +++ b/Assets/XLua/Gen/com_adjust_sdk_JSONArrayWrap.cs @@ -0,0 +1,401 @@ +#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 comadjustsdkJSONArrayWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(com.adjust.sdk.JSONArray); + Utils.BeginObjectRegister(type, L, translator, 0, 7, 2, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "get_Item", _m_get_Item); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "set_Item", _m_set_Item); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Add", _m_Add); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Remove", _m_Remove); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetEnumerator", _m_GetEnumerator); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Serialize", _m_Serialize); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Count", _g_get_Count); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Childs", _g_get_Childs); + + + + Utils.EndObjectRegister(type, L, translator, __CSIndexer, __NewIndexer, + 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 com.adjust.sdk.JSONArray(); + 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 com.adjust.sdk.JSONArray constructor!"); + + } + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __CSIndexer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + if (translator.Assignable(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + + com.adjust.sdk.JSONArray gen_to_be_invoked = (com.adjust.sdk.JSONArray)translator.FastGetCSObj(L, 1); + int index = LuaAPI.xlua_tointeger(L, 2); + LuaAPI.lua_pushboolean(L, true); + translator.Push(L, gen_to_be_invoked[index]); + return 2; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __NewIndexer(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + try { + + if (translator.Assignable(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && translator.Assignable(L, 3)) + { + + com.adjust.sdk.JSONArray gen_to_be_invoked = (com.adjust.sdk.JSONArray)translator.FastGetCSObj(L, 1); + int key = LuaAPI.xlua_tointeger(L, 2); + gen_to_be_invoked[key] = (com.adjust.sdk.JSONNode)translator.GetObject(L, 3, typeof(com.adjust.sdk.JSONNode)); + LuaAPI.lua_pushboolean(L, true); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_get_Item(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.JSONArray gen_to_be_invoked = (com.adjust.sdk.JSONArray)translator.FastGetCSObj(L, 1); + + + + { + + string key = LuaAPI.lua_tostring(L, 2); + translator.Push(L, gen_to_be_invoked[key]); + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_set_Item(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.JSONArray gen_to_be_invoked = (com.adjust.sdk.JSONArray)translator.FastGetCSObj(L, 1); + + + + { + + string key = LuaAPI.lua_tostring(L, 2); + com.adjust.sdk.JSONNode gen_value = (com.adjust.sdk.JSONNode)translator.GetObject(L, 3, typeof(com.adjust.sdk.JSONNode)); + gen_to_be_invoked[key] = gen_value; + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Add(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.JSONArray gen_to_be_invoked = (com.adjust.sdk.JSONArray)translator.FastGetCSObj(L, 1); + + + + { + string _aKey = LuaAPI.lua_tostring(L, 2); + com.adjust.sdk.JSONNode _aItem = (com.adjust.sdk.JSONNode)translator.GetObject(L, 3, typeof(com.adjust.sdk.JSONNode)); + + gen_to_be_invoked.Add( _aKey, _aItem ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Remove(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.JSONArray gen_to_be_invoked = (com.adjust.sdk.JSONArray)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _aIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.Remove( _aIndex ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + com.adjust.sdk.JSONNode _aNode = (com.adjust.sdk.JSONNode)translator.GetObject(L, 2, typeof(com.adjust.sdk.JSONNode)); + + var gen_ret = gen_to_be_invoked.Remove( _aNode ); + 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 com.adjust.sdk.JSONArray.Remove!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetEnumerator(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.JSONArray gen_to_be_invoked = (com.adjust.sdk.JSONArray)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetEnumerator( ); + 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_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.JSONArray gen_to_be_invoked = (com.adjust.sdk.JSONArray)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.ToString( ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _aPrefix = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.ToString( _aPrefix ); + LuaAPI.lua_pushstring(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 com.adjust.sdk.JSONArray.ToString!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Serialize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.JSONArray gen_to_be_invoked = (com.adjust.sdk.JSONArray)translator.FastGetCSObj(L, 1); + + + + { + System.IO.BinaryWriter _aWriter = (System.IO.BinaryWriter)translator.GetObject(L, 2, typeof(System.IO.BinaryWriter)); + + gen_to_be_invoked.Serialize( _aWriter ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Count(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.JSONArray gen_to_be_invoked = (com.adjust.sdk.JSONArray)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Count); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Childs(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.JSONArray gen_to_be_invoked = (com.adjust.sdk.JSONArray)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.Childs); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/com_adjust_sdk_JSONClassWrap.cs b/Assets/XLua/Gen/com_adjust_sdk_JSONClassWrap.cs new file mode 100644 index 000000000..a7c71a1e6 --- /dev/null +++ b/Assets/XLua/Gen/com_adjust_sdk_JSONClassWrap.cs @@ -0,0 +1,412 @@ +#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 comadjustsdkJSONClassWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(com.adjust.sdk.JSONClass); + Utils.BeginObjectRegister(type, L, translator, 0, 7, 2, 0); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "get_Item", _m_get_Item); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "set_Item", _m_set_Item); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Add", _m_Add); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Remove", _m_Remove); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetEnumerator", _m_GetEnumerator); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Serialize", _m_Serialize); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Count", _g_get_Count); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Childs", _g_get_Childs); + + + + Utils.EndObjectRegister(type, L, translator, __CSIndexer, __NewIndexer, + 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 com.adjust.sdk.JSONClass(); + 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 com.adjust.sdk.JSONClass constructor!"); + + } + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __CSIndexer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + if (translator.Assignable(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + + com.adjust.sdk.JSONClass gen_to_be_invoked = (com.adjust.sdk.JSONClass)translator.FastGetCSObj(L, 1); + int index = LuaAPI.xlua_tointeger(L, 2); + LuaAPI.lua_pushboolean(L, true); + translator.Push(L, gen_to_be_invoked[index]); + return 2; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __NewIndexer(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + try { + + if (translator.Assignable(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && translator.Assignable(L, 3)) + { + + com.adjust.sdk.JSONClass gen_to_be_invoked = (com.adjust.sdk.JSONClass)translator.FastGetCSObj(L, 1); + int key = LuaAPI.xlua_tointeger(L, 2); + gen_to_be_invoked[key] = (com.adjust.sdk.JSONNode)translator.GetObject(L, 3, typeof(com.adjust.sdk.JSONNode)); + LuaAPI.lua_pushboolean(L, true); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_get_Item(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.JSONClass gen_to_be_invoked = (com.adjust.sdk.JSONClass)translator.FastGetCSObj(L, 1); + + + + { + + string key = LuaAPI.lua_tostring(L, 2); + translator.Push(L, gen_to_be_invoked[key]); + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_set_Item(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.JSONClass gen_to_be_invoked = (com.adjust.sdk.JSONClass)translator.FastGetCSObj(L, 1); + + + + { + + string key = LuaAPI.lua_tostring(L, 2); + com.adjust.sdk.JSONNode gen_value = (com.adjust.sdk.JSONNode)translator.GetObject(L, 3, typeof(com.adjust.sdk.JSONNode)); + gen_to_be_invoked[key] = gen_value; + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Add(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.JSONClass gen_to_be_invoked = (com.adjust.sdk.JSONClass)translator.FastGetCSObj(L, 1); + + + + { + string _aKey = LuaAPI.lua_tostring(L, 2); + com.adjust.sdk.JSONNode _aItem = (com.adjust.sdk.JSONNode)translator.GetObject(L, 3, typeof(com.adjust.sdk.JSONNode)); + + gen_to_be_invoked.Add( _aKey, _aItem ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Remove(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.JSONClass gen_to_be_invoked = (com.adjust.sdk.JSONClass)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _aIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.Remove( _aIndex ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _aKey = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.Remove( _aKey ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + com.adjust.sdk.JSONNode _aNode = (com.adjust.sdk.JSONNode)translator.GetObject(L, 2, typeof(com.adjust.sdk.JSONNode)); + + var gen_ret = gen_to_be_invoked.Remove( _aNode ); + 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 com.adjust.sdk.JSONClass.Remove!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_GetEnumerator(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.JSONClass gen_to_be_invoked = (com.adjust.sdk.JSONClass)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetEnumerator( ); + 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_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.JSONClass gen_to_be_invoked = (com.adjust.sdk.JSONClass)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.ToString( ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _aPrefix = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.ToString( _aPrefix ); + LuaAPI.lua_pushstring(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 com.adjust.sdk.JSONClass.ToString!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Serialize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.JSONClass gen_to_be_invoked = (com.adjust.sdk.JSONClass)translator.FastGetCSObj(L, 1); + + + + { + System.IO.BinaryWriter _aWriter = (System.IO.BinaryWriter)translator.GetObject(L, 2, typeof(System.IO.BinaryWriter)); + + gen_to_be_invoked.Serialize( _aWriter ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Count(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.JSONClass gen_to_be_invoked = (com.adjust.sdk.JSONClass)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Count); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Childs(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.JSONClass gen_to_be_invoked = (com.adjust.sdk.JSONClass)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.Childs); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/com_adjust_sdk_JSONDataWrap.cs b/Assets/XLua/Gen/com_adjust_sdk_JSONDataWrap.cs new file mode 100644 index 000000000..6b8b79dc8 --- /dev/null +++ b/Assets/XLua/Gen/com_adjust_sdk_JSONDataWrap.cs @@ -0,0 +1,225 @@ +#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 comadjustsdkJSONDataWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(com.adjust.sdk.JSONData); + Utils.BeginObjectRegister(type, L, translator, 0, 2, 1, 1); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Serialize", _m_Serialize); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Value", _g_get_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) == 2 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _aData = LuaAPI.lua_tostring(L, 2); + + var gen_ret = new com.adjust.sdk.JSONData(_aData); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + float _aData = (float)LuaAPI.lua_tonumber(L, 2); + + var gen_ret = new com.adjust.sdk.JSONData(_aData); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + double _aData = LuaAPI.lua_tonumber(L, 2); + + var gen_ret = new com.adjust.sdk.JSONData(_aData); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) + { + bool _aData = LuaAPI.lua_toboolean(L, 2); + + var gen_ret = new com.adjust.sdk.JSONData(_aData); + translator.Push(L, gen_ret); + + return 1; + } + if(LuaAPI.lua_gettop(L) == 2 && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _aData = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = new com.adjust.sdk.JSONData(_aData); + 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 com.adjust.sdk.JSONData constructor!"); + + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.JSONData gen_to_be_invoked = (com.adjust.sdk.JSONData)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.ToString( ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _aPrefix = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.ToString( _aPrefix ); + LuaAPI.lua_pushstring(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 com.adjust.sdk.JSONData.ToString!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Serialize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.JSONData gen_to_be_invoked = (com.adjust.sdk.JSONData)translator.FastGetCSObj(L, 1); + + + + { + System.IO.BinaryWriter _aWriter = (System.IO.BinaryWriter)translator.GetObject(L, 2, typeof(System.IO.BinaryWriter)); + + gen_to_be_invoked.Serialize( _aWriter ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Value(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.JSONData gen_to_be_invoked = (com.adjust.sdk.JSONData)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); + + com.adjust.sdk.JSONData gen_to_be_invoked = (com.adjust.sdk.JSONData)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/com_adjust_sdk_JSONNodeWrap.cs b/Assets/XLua/Gen/com_adjust_sdk_JSONNodeWrap.cs new file mode 100644 index 000000000..b72dca014 --- /dev/null +++ b/Assets/XLua/Gen/com_adjust_sdk_JSONNodeWrap.cs @@ -0,0 +1,995 @@ +#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 comadjustsdkJSONNodeWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(com.adjust.sdk.JSONNode); + Utils.BeginObjectRegister(type, L, translator, 1, 12, 10, 5); + Utils.RegisterFunc(L, Utils.OBJ_META_IDX, "__eq", __EqMeta); + + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Add", _m_Add); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "get_Item", _m_get_Item); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "set_Item", _m_set_Item); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Remove", _m_Remove); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "ToString", _m_ToString); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Equals", _m_Equals); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetHashCode", _m_GetHashCode); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "Serialize", _m_Serialize); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SaveToStream", _m_SaveToStream); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SaveToCompressedStream", _m_SaveToCompressedStream); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SaveToCompressedFile", _m_SaveToCompressedFile); + Utils.RegisterFunc(L, Utils.METHOD_IDX, "SaveToCompressedBase64", _m_SaveToCompressedBase64); + + + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Value", _g_get_Value); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Count", _g_get_Count); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "Childs", _g_get_Childs); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "DeepChilds", _g_get_DeepChilds); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AsInt", _g_get_AsInt); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AsFloat", _g_get_AsFloat); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AsDouble", _g_get_AsDouble); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AsBool", _g_get_AsBool); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AsArray", _g_get_AsArray); + Utils.RegisterFunc(L, Utils.GETTER_IDX, "AsObject", _g_get_AsObject); + + Utils.RegisterFunc(L, Utils.SETTER_IDX, "Value", _s_set_Value); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "AsInt", _s_set_AsInt); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "AsFloat", _s_set_AsFloat); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "AsDouble", _s_set_AsDouble); + Utils.RegisterFunc(L, Utils.SETTER_IDX, "AsBool", _s_set_AsBool); + + + Utils.EndObjectRegister(type, L, translator, __CSIndexer, __NewIndexer, + null, null, null); + + Utils.BeginClassRegister(type, L, __CreateInstance, 8, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Parse", _m_Parse_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Deserialize", _m_Deserialize_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadFromCompressedFile", _m_LoadFromCompressedFile_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadFromCompressedStream", _m_LoadFromCompressedStream_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadFromCompressedBase64", _m_LoadFromCompressedBase64_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadFromStream", _m_LoadFromStream_xlua_st_); + Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadFromBase64", _m_LoadFromBase64_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 com.adjust.sdk.JSONNode(); + 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 com.adjust.sdk.JSONNode constructor!"); + + } + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __CSIndexer(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + if (translator.Assignable(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + + com.adjust.sdk.JSONNode gen_to_be_invoked = (com.adjust.sdk.JSONNode)translator.FastGetCSObj(L, 1); + int index = LuaAPI.xlua_tointeger(L, 2); + LuaAPI.lua_pushboolean(L, true); + translator.Push(L, gen_to_be_invoked[index]); + return 2; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + public static int __NewIndexer(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + try { + + if (translator.Assignable(L, 1) && LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2) && translator.Assignable(L, 3)) + { + + com.adjust.sdk.JSONNode gen_to_be_invoked = (com.adjust.sdk.JSONNode)translator.FastGetCSObj(L, 1); + int key = LuaAPI.xlua_tointeger(L, 2); + gen_to_be_invoked[key] = (com.adjust.sdk.JSONNode)translator.GetObject(L, 3, typeof(com.adjust.sdk.JSONNode)); + LuaAPI.lua_pushboolean(L, true); + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + LuaAPI.lua_pushboolean(L, false); + return 1; + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __EqMeta(RealStatePtr L) + { + + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + if (translator.Assignable(L, 1) && translator.Assignable(L, 2)) + { + com.adjust.sdk.JSONNode leftside = (com.adjust.sdk.JSONNode)translator.GetObject(L, 1, typeof(com.adjust.sdk.JSONNode)); + object rightside = translator.GetObject(L, 2, typeof(object)); + + LuaAPI.lua_pushboolean(L, leftside == rightside); + + return 1; + } + + } + catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return LuaAPI.luaL_error(L, "invalid arguments to right hand of == operator, need com.adjust.sdk.JSONNode!"); + + } + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Add(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.JSONNode gen_to_be_invoked = (com.adjust.sdk.JSONNode)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + com.adjust.sdk.JSONNode _aItem = (com.adjust.sdk.JSONNode)translator.GetObject(L, 2, typeof(com.adjust.sdk.JSONNode)); + + gen_to_be_invoked.Add( _aItem ); + + + + return 0; + } + if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable(L, 3)) + { + string _aKey = LuaAPI.lua_tostring(L, 2); + com.adjust.sdk.JSONNode _aItem = (com.adjust.sdk.JSONNode)translator.GetObject(L, 3, typeof(com.adjust.sdk.JSONNode)); + + gen_to_be_invoked.Add( _aKey, _aItem ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + return LuaAPI.luaL_error(L, "invalid arguments to com.adjust.sdk.JSONNode.Add!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_get_Item(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.JSONNode gen_to_be_invoked = (com.adjust.sdk.JSONNode)translator.FastGetCSObj(L, 1); + + + + { + + string key = LuaAPI.lua_tostring(L, 2); + translator.Push(L, gen_to_be_invoked[key]); + + + + return 1; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_set_Item(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.JSONNode gen_to_be_invoked = (com.adjust.sdk.JSONNode)translator.FastGetCSObj(L, 1); + + + + { + + string key = LuaAPI.lua_tostring(L, 2); + com.adjust.sdk.JSONNode gen_value = (com.adjust.sdk.JSONNode)translator.GetObject(L, 3, typeof(com.adjust.sdk.JSONNode)); + gen_to_be_invoked[key] = gen_value; + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Remove(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.JSONNode gen_to_be_invoked = (com.adjust.sdk.JSONNode)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) + { + int _aIndex = LuaAPI.xlua_tointeger(L, 2); + + var gen_ret = gen_to_be_invoked.Remove( _aIndex ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _aKey = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.Remove( _aKey ); + translator.Push(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& translator.Assignable(L, 2)) + { + com.adjust.sdk.JSONNode _aNode = (com.adjust.sdk.JSONNode)translator.GetObject(L, 2, typeof(com.adjust.sdk.JSONNode)); + + var gen_ret = gen_to_be_invoked.Remove( _aNode ); + 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 com.adjust.sdk.JSONNode.Remove!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_ToString(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.JSONNode gen_to_be_invoked = (com.adjust.sdk.JSONNode)translator.FastGetCSObj(L, 1); + + + int gen_param_count = LuaAPI.lua_gettop(L); + + if(gen_param_count == 1) + { + + var gen_ret = gen_to_be_invoked.ToString( ); + LuaAPI.lua_pushstring(L, gen_ret); + + + + return 1; + } + if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) + { + string _aPrefix = LuaAPI.lua_tostring(L, 2); + + var gen_ret = gen_to_be_invoked.ToString( _aPrefix ); + LuaAPI.lua_pushstring(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 com.adjust.sdk.JSONNode.ToString!"); + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Equals(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.JSONNode gen_to_be_invoked = (com.adjust.sdk.JSONNode)translator.FastGetCSObj(L, 1); + + + + { + object _obj = translator.GetObject(L, 2, typeof(object)); + + var gen_ret = gen_to_be_invoked.Equals( _obj ); + 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_GetHashCode(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.JSONNode gen_to_be_invoked = (com.adjust.sdk.JSONNode)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.GetHashCode( ); + 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_Parse_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _aJSON = LuaAPI.lua_tostring(L, 1); + + var gen_ret = com.adjust.sdk.JSONNode.Parse( _aJSON ); + 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_Serialize(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.JSONNode gen_to_be_invoked = (com.adjust.sdk.JSONNode)translator.FastGetCSObj(L, 1); + + + + { + System.IO.BinaryWriter _aWriter = (System.IO.BinaryWriter)translator.GetObject(L, 2, typeof(System.IO.BinaryWriter)); + + gen_to_be_invoked.Serialize( _aWriter ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SaveToStream(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.JSONNode gen_to_be_invoked = (com.adjust.sdk.JSONNode)translator.FastGetCSObj(L, 1); + + + + { + System.IO.Stream _aData = (System.IO.Stream)translator.GetObject(L, 2, typeof(System.IO.Stream)); + + gen_to_be_invoked.SaveToStream( _aData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SaveToCompressedStream(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.JSONNode gen_to_be_invoked = (com.adjust.sdk.JSONNode)translator.FastGetCSObj(L, 1); + + + + { + System.IO.Stream _aData = (System.IO.Stream)translator.GetObject(L, 2, typeof(System.IO.Stream)); + + gen_to_be_invoked.SaveToCompressedStream( _aData ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SaveToCompressedFile(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.JSONNode gen_to_be_invoked = (com.adjust.sdk.JSONNode)translator.FastGetCSObj(L, 1); + + + + { + string _aFileName = LuaAPI.lua_tostring(L, 2); + + gen_to_be_invoked.SaveToCompressedFile( _aFileName ); + + + + return 0; + } + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_SaveToCompressedBase64(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + com.adjust.sdk.JSONNode gen_to_be_invoked = (com.adjust.sdk.JSONNode)translator.FastGetCSObj(L, 1); + + + + { + + var gen_ret = gen_to_be_invoked.SaveToCompressedBase64( ); + 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 _m_Deserialize_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.IO.BinaryReader _aReader = (System.IO.BinaryReader)translator.GetObject(L, 1, typeof(System.IO.BinaryReader)); + + var gen_ret = com.adjust.sdk.JSONNode.Deserialize( _aReader ); + 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_LoadFromCompressedFile_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _aFileName = LuaAPI.lua_tostring(L, 1); + + var gen_ret = com.adjust.sdk.JSONNode.LoadFromCompressedFile( _aFileName ); + 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_LoadFromCompressedStream_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.IO.Stream _aData = (System.IO.Stream)translator.GetObject(L, 1, typeof(System.IO.Stream)); + + var gen_ret = com.adjust.sdk.JSONNode.LoadFromCompressedStream( _aData ); + 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_LoadFromCompressedBase64_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _aBase64 = LuaAPI.lua_tostring(L, 1); + + var gen_ret = com.adjust.sdk.JSONNode.LoadFromCompressedBase64( _aBase64 ); + 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_LoadFromStream_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + System.IO.Stream _aData = (System.IO.Stream)translator.GetObject(L, 1, typeof(System.IO.Stream)); + + var gen_ret = com.adjust.sdk.JSONNode.LoadFromStream( _aData ); + 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_LoadFromBase64_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _aBase64 = LuaAPI.lua_tostring(L, 1); + + var gen_ret = com.adjust.sdk.JSONNode.LoadFromBase64( _aBase64 ); + 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_Value(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.JSONNode gen_to_be_invoked = (com.adjust.sdk.JSONNode)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_Count(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.JSONNode gen_to_be_invoked = (com.adjust.sdk.JSONNode)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.Count); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_Childs(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.JSONNode gen_to_be_invoked = (com.adjust.sdk.JSONNode)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.Childs); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_DeepChilds(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.JSONNode gen_to_be_invoked = (com.adjust.sdk.JSONNode)translator.FastGetCSObj(L, 1); + translator.PushAny(L, gen_to_be_invoked.DeepChilds); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AsInt(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.JSONNode gen_to_be_invoked = (com.adjust.sdk.JSONNode)translator.FastGetCSObj(L, 1); + LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.AsInt); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AsFloat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.JSONNode gen_to_be_invoked = (com.adjust.sdk.JSONNode)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.AsFloat); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AsDouble(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.JSONNode gen_to_be_invoked = (com.adjust.sdk.JSONNode)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushnumber(L, gen_to_be_invoked.AsDouble); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AsBool(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.JSONNode gen_to_be_invoked = (com.adjust.sdk.JSONNode)translator.FastGetCSObj(L, 1); + LuaAPI.lua_pushboolean(L, gen_to_be_invoked.AsBool); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AsArray(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.JSONNode gen_to_be_invoked = (com.adjust.sdk.JSONNode)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.AsArray); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_AsObject(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.JSONNode gen_to_be_invoked = (com.adjust.sdk.JSONNode)translator.FastGetCSObj(L, 1); + translator.Push(L, gen_to_be_invoked.AsObject); + } 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); + + com.adjust.sdk.JSONNode gen_to_be_invoked = (com.adjust.sdk.JSONNode)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_AsInt(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.JSONNode gen_to_be_invoked = (com.adjust.sdk.JSONNode)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.AsInt = 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_AsFloat(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.JSONNode gen_to_be_invoked = (com.adjust.sdk.JSONNode)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.AsFloat = (float)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_AsDouble(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.JSONNode gen_to_be_invoked = (com.adjust.sdk.JSONNode)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.AsDouble = 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_AsBool(RealStatePtr L) + { + try { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + com.adjust.sdk.JSONNode gen_to_be_invoked = (com.adjust.sdk.JSONNode)translator.FastGetCSObj(L, 1); + gen_to_be_invoked.AsBool = LuaAPI.lua_toboolean(L, 2); + + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 0; + } + + + + + + } +} diff --git a/Assets/XLua/Gen/com_adjust_sdk_JSONWrap.cs b/Assets/XLua/Gen/com_adjust_sdk_JSONWrap.cs new file mode 100644 index 000000000..41fecf148 --- /dev/null +++ b/Assets/XLua/Gen/com_adjust_sdk_JSONWrap.cs @@ -0,0 +1,95 @@ +#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 comadjustsdkJSONWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(com.adjust.sdk.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, 2, 0, 0); + Utils.RegisterFunc(L, Utils.CLS_IDX, "Parse", _m_Parse_xlua_st_); + + + + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "com.adjust.sdk.JSON does not have a constructor!"); + } + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _m_Parse_xlua_st_(RealStatePtr L) + { + try { + + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + + + + + { + string _aJSON = LuaAPI.lua_tostring(L, 1); + + var gen_ret = com.adjust.sdk.JSON.Parse( _aJSON ); + 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/dataSourceWrap.cs b/Assets/XLua/Gen/dataSourceWrap.cs new file mode 100644 index 000000000..90e118fad --- /dev/null +++ b/Assets/XLua/Gen/dataSourceWrap.cs @@ -0,0 +1,80 @@ +#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 dataSourceWrap + { + public static void __Register(RealStatePtr L) + { + ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L); + System.Type type = typeof(dataSource); + 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, 1, 0); + + + + Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "MOPUB", _g_get_MOPUB); + + + + Utils.EndClassRegister(type, L, translator); + } + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int __CreateInstance(RealStatePtr L) + { + return LuaAPI.luaL_error(L, "dataSource does not have a constructor!"); + } + + + + + + + + + + + + [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))] + static int _g_get_MOPUB(RealStatePtr L) + { + try { + + LuaAPI.lua_pushstring(L, dataSource.MOPUB); + } catch(System.Exception gen_e) { + return LuaAPI.luaL_error(L, "c# exception:" + gen_e); + } + return 1; + } + + + + + + + + } +} diff --git a/Assets/XLua/Gen/link.xml b/Assets/XLua/Gen/link.xml new file mode 100644 index 000000000..7f0706a7e --- /dev/null +++ b/Assets/XLua/Gen/link.xml @@ -0,0 +1,748 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/ProjectSettings/ShaderGraphSettings.asset b/ProjectSettings/ShaderGraphSettings.asset new file mode 100644 index 000000000..9b28428b9 --- /dev/null +++ b/ProjectSettings/ShaderGraphSettings.asset @@ -0,0 +1,16 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!114 &1 +MonoBehaviour: + m_ObjectHideFlags: 61 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: de02f9e1d18f588468e474319d09a723, type: 3} + m_Name: + m_EditorClassIdentifier: + customInterpolatorErrorThreshold: 32 + customInterpolatorWarningThreshold: 16